Skip to content

wake.ir.expressions.binary_operation module #

BinaryOperation class #

Bases: ExpressionAbc

Example

x + y
Source code in wake/ir/expressions/binary_operation.py 
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
class BinaryOperation(ExpressionAbc):
    """
    !!! example
        ```solidity
        x + y
        ```
    """

    _ast_node: SolcBinaryOperation
    _parent: weakref.ReferenceType[SolidityAbc]  # TODO: make this more specific

    _left_expression: ExpressionAbc
    _operator: BinaryOpOperator
    _right_expression: ExpressionAbc
    _function_id: Optional[AstNodeId]

    def __init__(
        self,
        init: IrInitTuple,
        binary_operation: SolcBinaryOperation,
        parent: SolidityAbc,
    ):
        super().__init__(init, binary_operation, parent)
        self._operator = binary_operation.operator
        self._left_expression = ExpressionAbc.from_ast(
            init, binary_operation.left_expression, self
        )
        self._right_expression = ExpressionAbc.from_ast(
            init, binary_operation.right_expression, self
        )
        self._function_id = binary_operation.function
        if self._function_id is not None:
            init.reference_resolver.register_post_process_callback(self._post_process)

    def __iter__(self) -> Iterator[IrAbc]:
        yield self
        yield from self._left_expression
        yield from self._right_expression

    def _post_process(self, callback_params: CallbackParams):
        function = self.function
        assert function is not None
        function.register_reference(self)
        self._reference_resolver.register_destroy_callback(
            self.source_unit.file, partial(self._destroy, function)
        )

    def _destroy(self, function: FunctionDefinition) -> None:
        function.unregister_reference(self)

    @property
    def parent(self) -> SolidityAbc:
        return super().parent

    @property
    def children(self) -> Iterator[ExpressionAbc]:
        """
        Yields:
            Direct children of this node.
        """
        yield self._left_expression
        yield self._right_expression

    @property
    def operator(self) -> BinaryOpOperator:
        """
        Returns:
            Operator of the binary operation.
        """
        return self._operator

    @property
    def left_expression(self) -> ExpressionAbc:
        """
        Returns:
            Left expression of the binary operation.
        """
        return self._left_expression

    @property
    def right_expression(self) -> ExpressionAbc:
        """
        Returns:
            Right expression of the binary operation.
        """
        return self._right_expression

    @property
    def is_ref_to_state_variable(self) -> bool:
        return False

    @property
    @weak_self_lru_cache(maxsize=2048)
    def modifies_state(
        self,
    ) -> Set[Tuple[Union[ExpressionAbc, StatementAbc, YulAbc], ModifiesStateFlag]]:
        return (
            self.left_expression.modifies_state | self.right_expression.modifies_state
        )

    @property
    def function(self) -> Optional[FunctionDefinition]:
        """
        Is not `None` if the binary operation operates on user-defined value types with custom operators.

        !!! example
            The binary operation `a + b` on line 11 of the following example references the function `add` on line 6:
            ```solidity linenums="1"
            pragma solidity ^0.8.19;

            type Int is int;
            using {add as +} for Int global;

            function add(Int a, Int b) pure returns (Int) {
                return Int.wrap(Int.unwrap(a) + Int.unwrap(b));
            }

            function test(Int a, Int b) pure returns (Int) {
                return a + b; // Equivalent to add(a, b)
            }
            ```

        Returns:
            Function representing the user-defined operator.
        """
        if self._function_id is None:
            return None
        node = self._reference_resolver.resolve_node(
            self._function_id, self.source_unit.cu_hash
        )
        assert isinstance(node, FunctionDefinition)
        return node

children: Iterator[ExpressionAbc] property #

Yields:

Type Description
ExpressionAbc

Direct children of this node.

function: Optional[FunctionDefinition] property #

Is not None if the binary operation operates on user-defined value types with custom operators.

Example

The binary operation a + b on line 11 of the following example references the function add on line 6: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
pragma solidity ^0.8.19;

type Int is int;
using {add as +} for Int global;

function add(Int a, Int b) pure returns (Int) {
    return Int.wrap(Int.unwrap(a) + Int.unwrap(b));
}

function test(Int a, Int b) pure returns (Int) {
    return a + b; // Equivalent to add(a, b)
}

Returns:

Type Description
Optional[FunctionDefinition]

Function representing the user-defined operator.

left_expression: ExpressionAbc property #

Returns:

Type Description
ExpressionAbc

Left expression of the binary operation.

operator: BinaryOpOperator property #

Returns:

Type Description
BinaryOpOperator

Operator of the binary operation.

right_expression: ExpressionAbc property #

Returns:

Type Description
ExpressionAbc

Right expression of the binary operation.