Skip to content

wake.ir.type_names.array_type_name module #

ArrayTypeName class #

Bases: TypeNameAbc

Array type name.

Example

An array type name can be used:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
function or(bool[] memory arr) pure returns(bool) {
    for (uint i = 0; i < arr.length; i++)
        if (arr[i])
            return true;
    return false;
}

using {or} for bool[];

contract C {
    int[10][20] arr;
    string[10] names;
    mapping(address => C[]) map;

    function foo() public pure {
        address[] memory addresses = new address[](5);
    }
}
Source code in wake/ir/type_names/array_type_name.py 
 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
138
139
140
141
142
143
144
145
146
147
148
class ArrayTypeName(TypeNameAbc):
    """
    Array type name.

    !!! example
        An array type name can be used:

        - inside a [VariableDeclaration][wake.ir.declarations.variable_declaration.VariableDeclaration]:
            - `:::solidity bool[]` on line 1,
            - `:::solidity int[10][20]` on line 11,
            - `:::solidity string[10]` on line 12,
            - `:::solidity address[]` on line 16,
        - inside a [NewExpression][wake.ir.expressions.new_expression.NewExpression]:
            - `:::solidity address[]` on line 16,
        - inside a [UsingForDirective][wake.ir.meta.using_for_directive.UsingForDirective]:
            - `:::solidity bool[]` on line 8,
        - inside an [ArrayTypeName][wake.ir.type_names.array_type_name.ArrayTypeName]:
            - `:::solidity int[10]` on line 11,
        - inside a [Mapping][wake.ir.type_names.mapping.Mapping]:
            - `:::solidity C[]` on line 13.

        ```solidity linenums="1"
        function or(bool[] memory arr) pure returns(bool) {
            for (uint i = 0; i < arr.length; i++)
                if (arr[i])
                    return true;
            return false;
        }

        using {or} for bool[];

        contract C {
            int[10][20] arr;
            string[10] names;
            mapping(address => C[]) map;

            function foo() public pure {
                address[] memory addresses = new address[](5);
            }
        }
        ```
    """

    _ast_node: SolcArrayTypeName
    _parent: weakref.ReferenceType[
        Union[
            VariableDeclaration,
            NewExpression,
            UsingForDirective,
            ArrayTypeName,
            Mapping,
        ]
    ]

    _base_type: TypeNameAbc
    _length: Optional[ExpressionAbc]

    def __init__(
        self, init: IrInitTuple, array_type_name: SolcArrayTypeName, parent: SolidityAbc
    ):
        super().__init__(init, array_type_name, parent)
        self._base_type = TypeNameAbc.from_ast(init, array_type_name.base_type, self)
        self._length = (
            ExpressionAbc.from_ast(init, array_type_name.length, self)
            if array_type_name.length is not None
            else None
        )

    def __iter__(self) -> Iterator[IrAbc]:
        yield self
        yield from self._base_type
        if self._length is not None:
            yield from self._length

    @property
    def parent(
        self,
    ) -> Union[
        VariableDeclaration, NewExpression, UsingForDirective, ArrayTypeName, Mapping
    ]:
        """
        Returns:
            Parent IR node.
        """
        return super().parent

    @property
    def children(self) -> Iterator[Union[TypeNameAbc, ExpressionAbc]]:
        """
        Yields:
            Direct children of this node.
        """
        yield self._base_type
        if self._length is not None:
            yield self._length

    @property
    def type(self) -> Array:
        """
        Returns:
            Type description.
        """
        t = super().type
        assert isinstance(t, Array)
        return t

    @property
    def base_type(self) -> TypeNameAbc:
        """
        !!! example
            `uint8[2]` has `uint8` ([ElementaryTypeName][wake.ir.type_names.elementary_type_name.ElementaryTypeName]) as a base type.

            `uint8[2][3]` has `uint8[2]` ([ArrayTypeName][wake.ir.type_names.array_type_name.ArrayTypeName]) as a base type.

        Returns:
            Type name IR node describing the base type.
        """
        return self._base_type

    @property
    def length(self) -> Optional[ExpressionAbc]:
        """
        Returns an expression as present in the source code.

        Returns:
            Expression defining the length of the array.
        """
        return self._length

base_type: TypeNameAbc property #

Example

uint8[2] has uint8 (ElementaryTypeName) as a base type.

uint8[2][3] has uint8[2] (ArrayTypeName) as a base type.

Returns:

Type Description
TypeNameAbc

Type name IR node describing the base type.

children: Iterator[Union[TypeNameAbc, ExpressionAbc]] property #

Yields:

Type Description
Union[TypeNameAbc, ExpressionAbc]

Direct children of this node.

length: Optional[ExpressionAbc] property #

Returns an expression as present in the source code.

Returns:

Type Description
Optional[ExpressionAbc]

Expression defining the length of the array.

parent: Union[VariableDeclaration, NewExpression, UsingForDirective, ArrayTypeName, Mapping] property #

Returns:

Type Description
Union[VariableDeclaration, NewExpression, UsingForDirective, ArrayTypeName, Mapping]

Parent IR node.

type: Array property #

Returns:

Type Description
Array

Type description.