Skip to content

wake.ir.expressions.unary_operation module #

UnaryOperation class #

Bases: ExpressionAbc

Example

-x
Source code in wake/ir/expressions/unary_operation.py 
 16
 17
 18
 19
 20
 21
 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
class UnaryOperation(ExpressionAbc):
    """
    !!! example
        ```solidity
        -x
        ```
    """

    _ast_node: SolcUnaryOperation
    _parent: weakref.ReferenceType[SolidityAbc]

    _operator: UnaryOpOperator
    _prefix: bool
    _sub_expression: ExpressionAbc
    _function_id: Optional[AstNodeId]

    def __init__(
        self,
        init: IrInitTuple,
        unary_operation: SolcUnaryOperation,
        parent: SolidityAbc,
    ):
        super().__init__(init, unary_operation, parent)
        self._operator = unary_operation.operator
        self._prefix = unary_operation.prefix
        self._sub_expression = ExpressionAbc.from_ast(
            init, unary_operation.sub_expression, self
        )
        self._function_id = unary_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._sub_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._sub_expression

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

    @property
    def prefix(self) -> bool:
        """
        Returns:
            `False` for `++` and `--` operators applied as postfix operators, `True` otherwise.
        """
        return self._prefix

    @property
    def sub_expression(self) -> ExpressionAbc:
        """
        Returns:
            Sub-expression the unary operator is applied to.
        """
        return self._sub_expression

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

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

        !!! note
            Only `~` and `-` may be defined as user-defined unary operators.

        !!! example
            The unary operation `:::solidity ~a` on line 11 of the following example references the function `negate` on line 6:
            ```solidity linenums="1"
            pragma solidity ^0.8.19;

            type Int is int;
            using {negate as ~} for Int global;

            function negate(Int a) pure returns (Int) {
                return Int.wrap(-Int.unwrap(a));
            }

            function test(Int a) pure returns (Int) {
                return ~a;
            }
            ```

        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 unary operation operates on user-defined value types with custom operators.

Note

Only ~ and - may be defined as user-defined unary operators.

Example

The unary operation ~a on line 11 of the following example references the function negate 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 {negate as ~} for Int global;

function negate(Int a) pure returns (Int) {
    return Int.wrap(-Int.unwrap(a));
}

function test(Int a) pure returns (Int) {
    return ~a;
}

Returns:

Type Description
Optional[FunctionDefinition]

Function representing the user-defined operator.

operator: UnaryOpOperator property #

Returns:

Type Description
UnaryOpOperator

Operator of the unary operation.

prefix: bool property #

Returns:

Type Description
bool

False for ++ and -- operators applied as postfix operators, True otherwise.

sub_expression: ExpressionAbc property #

Returns:

Type Description
ExpressionAbc

Sub-expression the unary operator is applied to.