e084b44c-1a5f-4649-92cd-d3ed06099181

Committed 05 Mar 2024 05:58PM UTC coverage: 92.023% (-0.08%) from 92.107%

Build # e084b44c-1a5f-4649-92cd-d3ed06099181

Build Type

push

circleci

Committed by Mirella de Medeiros

Commit Message

CU-86drpnc9z - Drop support to Python 3.10

Run Details

20547 of 22328 relevant lines covered (92.02%)

1.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.1

/boa3/internal/model/builtin/classmethod/countsequencemethod.py

from boa3.internal.model.builtin.classmethod.countmethod import CountMethod
from boa3.internal.model.expression import IExpression
from boa3.internal.model.type.collection.sequence.sequencetype import SequenceType
from boa3.internal.model.type.itype import IType
from boa3.internal.model.variable import Variable


class CountSequenceMethod(CountMethod):

    def __init__(self, sequence_type: SequenceType | None = None, arg_value: IType | None = None):
        from boa3.internal.model.type.type import Type
        if not isinstance(sequence_type, SequenceType):
            sequence_type = Type.sequence
        if not isinstance(arg_value, IType):
            arg_value = Type.any

        args: dict[str, Variable] = {
            'self': Variable(sequence_type),
            'value': Variable(arg_value)
        }

        super().__init__(args)

    def validate_parameters(self, *params: IExpression) -> bool:
        if len(params) != 2:
            return False
        if not all(isinstance(param, IExpression) for param in params):
            return False

        from boa3.internal.model.type.itype import IType
        sequence_type: IType = params[0].type

        if not isinstance(sequence_type, SequenceType):
            return False
        from boa3.internal.model.type.collection.sequence.mutable.listtype import ListType
        from boa3.internal.model.type.collection.sequence.tupletype import TupleType
        from boa3.internal.model.type.collection.sequence.rangetype import RangeType
        if not isinstance(sequence_type, (ListType, TupleType, RangeType)):
            return False
        return True

    def generate_internal_opcodes(self, code_generator):
        from boa3.internal.model.builtin.builtin import Builtin
        from boa3.internal.model.operation.binaryop import BinaryOp
        from boa3.internal.neo.vm.opcode.Opcode import Opcode

        # aux = self.copy()
        code_generator.convert_copy()

        # count = 0
        code_generator.convert_literal(0)

        # index = len(sequence) - 1
        code_generator.duplicate_stack_item(2)
        code_generator.convert_builtin_method_call(Builtin.Len, is_internal=True)
        code_generator.insert_opcode(Opcode.DEC)

        # while index >= 0:
        while_start = code_generator.convert_begin_while()

        jmps_to_inc, jmps_to_condition = self._generic_verification(code_generator)

        #   element = sequence[index]
        code_generator.duplicate_stack_item(3)
        code_generator.duplicate_stack_item(2)
        code_generator.convert_get_item(index_inserted_internally=True)

        #   if element == value:
        code_generator.duplicate_stack_item(5)
        is_equal = code_generator.convert_begin_if()
        code_generator.change_jump(is_equal, Opcode.JMPNE)

        for address in jmps_to_inc:
            code_generator.convert_end_if(address, is_internal=True)

        #       count += 1
        code_generator.swap_reverse_stack_items(2)
        code_generator.insert_opcode(Opcode.INC)
        code_generator.swap_reverse_stack_items(2)

        code_generator.convert_end_if(is_equal)
        for address in jmps_to_condition:
            code_generator.convert_end_if(address, is_internal=True)

        #   index -= 1
        code_generator.insert_opcode(Opcode.DEC)

        # while condition
        while_condition = code_generator.bytecode_size
        code_generator.duplicate_stack_top_item()
        code_generator.insert_opcode(Opcode.SIGN)
        code_generator.convert_literal(0)
        code_generator.convert_operation(BinaryOp.GtE)

        code_generator.convert_end_while(while_start, while_condition, is_internal=True)

        # clean stack
        code_generator.remove_stack_top_item()
        code_generator.swap_reverse_stack_items(3)
        code_generator.remove_stack_top_item()
        code_generator.remove_stack_top_item()

    def _generic_verification(self, code_generator) -> tuple[list[int], list[int]]:
        """
        Generate the Neo VM opcodes for the method.

        :type code_generator: boa3.internal.compiler.codegenerator.codegenerator.CodeGenerator
        """
        return [], []

1	from boa3.internal.model.builtin.classmethod.countmethod import CountMethod	2✔
2	from boa3.internal.model.expression import IExpression	2✔
3	from boa3.internal.model.type.collection.sequence.sequencetype import SequenceType	2✔
4	from boa3.internal.model.type.itype import IType	2✔
5	from boa3.internal.model.variable import Variable	2✔
6
7
8	class CountSequenceMethod(CountMethod):	2✔
9
10	def __init__(self, sequence_type: SequenceType \| None = None, arg_value: IType \| None = None):	2✔
11	from boa3.internal.model.type.type import Type	2✔
12	if not isinstance(sequence_type, SequenceType):	2✔
13	sequence_type = Type.sequence	2✔
14	if not isinstance(arg_value, IType):	2✔
15	arg_value = Type.any	2✔
16
17	args: dict[str, Variable] = {	2✔
18	'self': Variable(sequence_type),
19	'value': Variable(arg_value)
20	}
21
22	super().__init__(args)	2✔
23
24	def validate_parameters(self, *params: IExpression) -> bool:	2✔
25	if len(params) != 2:	×
26	return False	×
27	if not all(isinstance(param, IExpression) for param in params):	×
28	return False	×
29
30	from boa3.internal.model.type.itype import IType	×
31	sequence_type: IType = params[0].type	×
32
33	if not isinstance(sequence_type, SequenceType):	×
34	return False	×
35	from boa3.internal.model.type.collection.sequence.mutable.listtype import ListType	×
36	from boa3.internal.model.type.collection.sequence.tupletype import TupleType	×
37	from boa3.internal.model.type.collection.sequence.rangetype import RangeType	×
38	if not isinstance(sequence_type, (ListType, TupleType, RangeType)):	×
39	return False	×
40	return True	×
41
42	def generate_internal_opcodes(self, code_generator):	2✔
43	from boa3.internal.model.builtin.builtin import Builtin	2✔
44	from boa3.internal.model.operation.binaryop import BinaryOp	2✔
45	from boa3.internal.neo.vm.opcode.Opcode import Opcode	2✔
46
47	# aux = self.copy()
48	code_generator.convert_copy()	2✔
49
50	# count = 0
51	code_generator.convert_literal(0)	2✔
52
53	# index = len(sequence) - 1
54	code_generator.duplicate_stack_item(2)	2✔
55	code_generator.convert_builtin_method_call(Builtin.Len, is_internal=True)	2✔
56	code_generator.insert_opcode(Opcode.DEC)	2✔
57
58	# while index >= 0:
59	while_start = code_generator.convert_begin_while()	2✔
60
61	jmps_to_inc, jmps_to_condition = self._generic_verification(code_generator)	2✔
62
63	# element = sequence[index]
64	code_generator.duplicate_stack_item(3)	2✔
65	code_generator.duplicate_stack_item(2)	2✔
66	code_generator.convert_get_item(index_inserted_internally=True)	2✔
67
68	# if element == value:
69	code_generator.duplicate_stack_item(5)	2✔
70	is_equal = code_generator.convert_begin_if()	2✔
71	code_generator.change_jump(is_equal, Opcode.JMPNE)	2✔
72
73	for address in jmps_to_inc:	2✔
74	code_generator.convert_end_if(address, is_internal=True)	2✔
75
76	# count += 1
77	code_generator.swap_reverse_stack_items(2)	2✔
78	code_generator.insert_opcode(Opcode.INC)	2✔
79	code_generator.swap_reverse_stack_items(2)	2✔
80
81	code_generator.convert_end_if(is_equal)	2✔
82	for address in jmps_to_condition:	2✔
83	code_generator.convert_end_if(address, is_internal=True)	2✔
84
85	# index -= 1
86	code_generator.insert_opcode(Opcode.DEC)	2✔
87
88	# while condition
89	while_condition = code_generator.bytecode_size	2✔
90	code_generator.duplicate_stack_top_item()	2✔
91	code_generator.insert_opcode(Opcode.SIGN)	2✔
92	code_generator.convert_literal(0)	2✔
93	code_generator.convert_operation(BinaryOp.GtE)	2✔
94
95	code_generator.convert_end_while(while_start, while_condition, is_internal=True)	2✔
96
97	# clean stack
98	code_generator.remove_stack_top_item()	2✔
99	code_generator.swap_reverse_stack_items(3)	2✔
100	code_generator.remove_stack_top_item()	2✔
101	code_generator.remove_stack_top_item()	2✔
102
103	def _generic_verification(self, code_generator) -> tuple[list[int], list[int]]:	2✔
104	"""
105	Generate the Neo VM opcodes for the method.
106
107	:type code_generator: boa3.internal.compiler.codegenerator.codegenerator.CodeGenerator
108	"""
109	return [], []	2✔

CityOfZion / neo3-boa / e084b44c-1a5f-4649-92cd-d3ed06099181

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous