858f5658-b835-4f01-86b4-3a69cebd0b86

Committed 16 Oct 2023 06:23PM UTC coverage: 91.625% (+0.004%) from 91.621%

Build # 858f5658-b835-4f01-86b4-3a69cebd0b86

Build Type

push

circleci

Committed by Mirella de Medeiros

Commit Message

Bump version: 1.0.1 → 1.1.0

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

19988 of 21815 relevant lines covered (91.63%)

0.92 hits per line

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

79.41

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

from typing import Dict, List, Optional, Tuple

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

CityOfZion / neo3-boa / 858f5658-b835-4f01-86b4-3a69cebd0b86

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