Skip to content

User defined type name

woke.ast.ir.type_name.user_defined_type_name module #

UserDefinedTypeName class #

Bases: TypeNameAbc

User defined type name represents a name path to a user defined type. Path parts are separated by dots. In Solidity 0.8.0 a new IR node (IdentifierPath) was introduced to replace UserDefinedTypeName in some cases.

Example

A user defined type name can be used:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
pragma solidity 0.7;

interface Interface {
    enum Enum {
        READY,
        WAITING
    }

    struct Struct {
        uint a;
    }

    function foo() external;
}

library Lib {}

function tmp(Interface.Struct memory s) {
    s.a = 5;
    new Contract();
}

contract Contract is Interface {
    using Lib for Interface.Struct;

    Interface.Enum state;
    Interface.Enum[] states;
    mapping(Interface.Enum => Interface.Enum) map;

    function foo() external override(Interface) {
    }
}
Source code in woke/ast/ir/type_name/user_defined_type_name.py 
 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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
class UserDefinedTypeName(TypeNameAbc):
    """
    User defined type name represents a name path to a user defined type. Path parts are separated by dots.
    In Solidity 0.8.0 a new IR node ([IdentifierPath][woke.ast.ir.meta.identifier_path.IdentifierPath]) was introduced to replace [UserDefinedTypeName][woke.ast.ir.type_name.user_defined_type_name.UserDefinedTypeName] in some cases.

    !!! example
        A user defined type name can be used:

        - inside a [VariableDeclaration][woke.ast.ir.declaration.variable_declaration.VariableDeclaration]:
            - `:::solidity Interface.Struct` in line 18,
            - `:::solidity Interface.Enum` in line 26,
        - inside a [NewExpression][woke.ast.ir.expression.new_expression.NewExpression]:
            - `:::solidity Contract` in line 20,
        - inside an [InheritanceSpecifier][woke.ast.ir.meta.inheritance_specifier.InheritanceSpecifier]:
            - `:::solidity Interface` in line 23,
        - inside an [OverrideSpecifier][woke.ast.ir.meta.override_specifier.OverrideSpecifier]:
            - `:::solidity Interface` in line 30,
        - inside a [UsingForDirective][woke.ast.ir.meta.using_for_directive.UsingForDirective]:
            - `:::solidity Lib` in line 24,
            - `:::solidity Interface.Struct` in line 24,
        - inside an [ArrayTypeName][woke.ast.ir.type_name.array_type_name.ArrayTypeName]:
            - `:::solidity Interface.Enum` in line 27,
        - inside a [Mapping][woke.ast.ir.type_name.mapping.Mapping]:
            - both occurrences of `:::solidity Interface.Enum` in line 28.

        ```solidity linenums="1"
        pragma solidity 0.7;

        interface Interface {
            enum Enum {
                READY,
                WAITING
            }

            struct Struct {
                uint a;
            }

            function foo() external;
        }

        library Lib {}

        function tmp(Interface.Struct memory s) {
            s.a = 5;
            new Contract();
        }

        contract Contract is Interface {
            using Lib for Interface.Struct;

            Interface.Enum state;
            Interface.Enum[] states;
            mapping(Interface.Enum => Interface.Enum) map;

            function foo() external override(Interface) {
            }
        }
        ```
    """

    _ast_node: SolcUserDefinedTypeName
    _parent: Union[
        VariableDeclaration,
        NewExpression,
        InheritanceSpecifier,
        OverrideSpecifier,
        UsingForDirective,
        ArrayTypeName,
        Mapping,
    ]

    _referenced_declaration_id: AstNodeId
    _contract_scope_id: Optional[AstNodeId]
    _name: Optional[str]
    _path_node: Optional[IdentifierPath]
    _parts: Optional[IntervalTree]

    def __init__(
        self,
        init: IrInitTuple,
        user_defined_type_name: SolcUserDefinedTypeName,
        parent: SolidityAbc,
    ):
        super().__init__(init, user_defined_type_name, parent)
        self._name = user_defined_type_name.name
        self._referenced_declaration_id = user_defined_type_name.referenced_declaration
        assert self._referenced_declaration_id >= 0
        self._contract_scope_id = user_defined_type_name.contract_scope
        if user_defined_type_name.path_node is None:
            self._path_node = None
            matches = list(IDENTIFIER_RE.finditer(self._source))
            groups_count = len(matches)
            assert groups_count > 0

            self._parts = IntervalTree()
            for i, match in enumerate(matches):
                name = match.group(0).decode("utf-8")
                start = self.byte_location[0] + match.start()
                end = self.byte_location[0] + match.end()
                self._parts[start:end] = IdentifierPathPart(
                    self,
                    init,
                    (start, end),
                    name,
                    self._referenced_declaration_id,
                    groups_count - i - 1,
                )
        else:
            self._path_node = IdentifierPath(
                init, user_defined_type_name.path_node, self
            )
            self._parts = None

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

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

    @property
    def type(self) -> Union[Contract, Struct, Enum, UserDefinedValueType]:
        """
        Returns:
            Type description.
        """
        t = super().type
        assert isinstance(t, (Contract, Struct, Enum, UserDefinedValueType))
        return t

    @property
    def name(self) -> str:
        """
        !!! note
            Should be the same as [source][woke.ast.ir.abc.IrAbc.source] and is the same as [path_node.name][woke.ast.ir.meta.identifier_path.IdentifierPath.name] if [path_node][woke.ast.ir.type_name.user_defined_type_name.UserDefinedTypeName.path_node] is not `None`.
        Returns:
            Name of the user defined type as it appears in the source code.
        """
        if self._name is None:
            assert self._path_node is not None
            self._name = self._path_node.name
        return self._name

    @property
    def identifier_path_parts(self) -> Tuple[IdentifierPathPart, ...]:
        """
        Returns:
            Parts of the user defined type name.
        """
        if self._path_node is not None:
            return self._path_node.identifier_path_parts

        assert self._parts is not None
        return tuple(interval.data for interval in sorted(self._parts))

    def identifier_path_part_at(self, byte_offset: int) -> Optional[IdentifierPathPart]:
        """
        Args:
            byte_offset: Byte offset in the source file.
        Returns:
            Identifier path part at the given byte offset, if any.
        """
        if self._path_node is not None:
            return self._path_node.identifier_path_part_at(byte_offset)

        assert self._parts is not None
        intervals = self._parts.at(byte_offset)
        assert len(intervals) <= 1
        if len(intervals) == 0:
            return None
        return intervals.pop().data

    @property
    def referenced_declaration(self) -> DeclarationAbc:
        """
        Returns:
            Declaration IR node referenced by this user defined type name.
        """
        node = self._reference_resolver.resolve_node(
            self._referenced_declaration_id, self._cu_hash
        )
        assert isinstance(node, DeclarationAbc)
        return node

    @property
    def path_node(self) -> Optional[IdentifierPath]:
        """
        Always present since Solidity 0.8.0. If not `None`, it represents the same source code as this node ([byte_location][woke.ast.ir.abc.IrAbc.byte_location] properties are the same) and references the same declaration.
        Returns:
            Identifier path IR node.
        """
        return self._path_node

identifier_path_parts: Tuple[IdentifierPathPart, ...] property #

Returns:

Type Description
Tuple[IdentifierPathPart, ...]

Parts of the user defined type name.

name: str property #

Note

Should be the same as source and is the same as path_node.name if path_node is not None.

Returns:

Type Description
str

Name of the user defined type as it appears in the source code.

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

Returns:

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

Parent IR node.

path_node: Optional[IdentifierPath] property #

Always present since Solidity 0.8.0. If not None, it represents the same source code as this node (byte_location properties are the same) and references the same declaration.

Returns:

Type Description
Optional[IdentifierPath]

Identifier path IR node.

referenced_declaration: DeclarationAbc property #

Returns:

Type Description
DeclarationAbc

Declaration IR node referenced by this user defined type name.

type: Union[Contract, Struct, Enum, UserDefinedValueType] property #

Returns:

Type Description
Union[Contract, Struct, Enum, UserDefinedValueType]

Type description.

identifier_path_part_at(byte_offset) #

Parameters:

Name Type Description Default
byte_offset int

Byte offset in the source file.

 required

Returns:

Type Description
Optional[IdentifierPathPart]

Identifier path part at the given byte offset, if any.
Source code in woke/ast/ir/type_name/user_defined_type_name.py 
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
def identifier_path_part_at(self, byte_offset: int) -> Optional[IdentifierPathPart]:
    """
    Args:
        byte_offset: Byte offset in the source file.
    Returns:
        Identifier path part at the given byte offset, if any.
    """
    if self._path_node is not None:
        return self._path_node.identifier_path_part_at(byte_offset)

    assert self._parts is not None
    intervals = self._parts.at(byte_offset)
    assert len(intervals) <= 1
    if len(intervals) == 0:
        return None
    return intervals.pop().data