Skip to content

Elementary type name

woke.ast.ir.type_name.elementary_type_name module #

ElementaryTypeName class #

Bases: TypeNameAbc

Elementary type name.

Example

An elementary type name can be used:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
function add(uint a, uint b) pure returns(int) {
    return int(a + b);
}

using {add} for uint;

type MyInt is int;

contract C {
    string public str;
    uint[10] arr;
    mapping(address => MyInt) map;

    function foo() public pure {
        bytes memory b = new bytes(10);
    }
}
Source code in woke/ast/ir/type_name/elementary_type_name.py 
 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
class ElementaryTypeName(TypeNameAbc):
    """
    Elementary type name.

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

        - inside a [VariableDeclaration][woke.ast.ir.declaration.variable_declaration.VariableDeclaration]:
            - both occurrences of `:::solidity uint` in line 1,
            - `:::solidity int` in line 1,
            - `:::solidity string` in line 10,
            - the first occurrence of `:::solidity bytes` in line 15,
        - inside a [UserDefinedValueTypeDefinition][woke.ast.ir.declaration.user_defined_value_type_definition.UserDefinedValueTypeDefinition]:
            - `:::solidity int` in line 7,
        - inside an [ElementaryTypeNameExpression][woke.ast.ir.expression.elementary_type_name_expression.ElementaryTypeNameExpression]:
            - `:::solidity int` in line 2,
        - inside a [NewExpression][woke.ast.ir.expression.new_expression.NewExpression]:
            - the second occurrence of `:::solidity bytes` in line 15,
        - inside a [UsingForDirective][woke.ast.ir.meta.using_for_directive.UsingForDirective]:
            - `:::solidity uint` in line 5,
        - inside an [ArrayTypeName][woke.ast.ir.type_name.array_type_name.ArrayTypeName]:
            - `:::solidity uint` in line 11,
        - inside a [Mapping][woke.ast.ir.type_name.mapping.Mapping]:
            - `:::solidity address` in line 12.

        ```solidity linenums="1"
        function add(uint a, uint b) pure returns(int) {
            return int(a + b);
        }

        using {add} for uint;

        type MyInt is int;

        contract C {
            string public str;
            uint[10] arr;
            mapping(address => MyInt) map;

            function foo() public pure {
                bytes memory b = new bytes(10);
            }
        }
        ```
    """
    _ast_node: SolcElementaryTypeName
    _parent: Union[VariableDeclaration, UserDefinedValueTypeDefinition, ElementaryTypeNameExpression, NewExpression, UsingForDirective, ArrayTypeName, Mapping]

    _name: str
    _state_mutability: Optional[StateMutability]

    def __init__(
        self,
        init: IrInitTuple,
        elementary_type_name: SolcElementaryTypeName,
        parent: SolidityAbc,
    ):
        super().__init__(init, elementary_type_name, parent)
        self._name = elementary_type_name.name
        self._state_mutability = elementary_type_name.state_mutability

        from woke.ast.ir.expression.elementary_type_name_expression import (
            ElementaryTypeNameExpression,
        )

        # fix missing type descriptions in AST
        if self._type_descriptions.type_identifier is None and isinstance(
            parent, ElementaryTypeNameExpression
        ):
            self._type_descriptions = parent._type_descriptions

    @property
    def parent(self) -> Union[VariableDeclaration, UserDefinedValueTypeDefinition, ElementaryTypeNameExpression, NewExpression, UsingForDirective, ArrayTypeName, Mapping]:
        """
        When the parent is a [NewExpression][woke.ast.ir.expression.new_expression.NewExpression], this can only be `bytes` or `string`.
        Returns:
            Parent IR node.
        """
        return self._parent

    @property
    def type(self) -> Union[Address, Bool, Int, UInt, Fixed, UFixed, String, Bytes, FixedBytes, Type]:
        """
        Returns either the generic [Type][woke.ast.types.Type] expression type (this is the case of a type conversion, for example `:::solidity address(0)`) or directly one of the elementary expression types.
        Returns:
            Type description.
        """
        t = super().type
        if not isinstance(t, (Address, Bool, Int, UInt, Fixed, UFixed, String, Bytes, FixedBytes, Type)):
            raise TypeError(f"Unexpected type {t} {self.source}")
        assert isinstance(t, (Address, Bool, Int, UInt, Fixed, UFixed, String, Bytes, FixedBytes, Type))
        return t

    @property
    def name(self) -> str:
        """
        !!! example
            For example `uint256`, `bool`, `string`, `bytes1` or `address`.

        !!! tip
            Instead of working with the name, it may be better to use the [type][woke.ast.ir.type_name.elementary_type_name.ElementaryTypeName.type] property.
        Returns:
            Name of the elementary type.
        """
        return self._name

    @property
    def state_mutability(self) -> Optional[StateMutability]:
        """
        Is only set for `address` as either [StateMutability.PAYABLE][woke.ast.enums.StateMutability.PAYABLE] or [StateMutability.NONPAYABLE][woke.ast.enums.StateMutability.NONPAYABLE].
        Returns:
            State mutability of the `address` type.
        """
        return self._state_mutability

name: str property #

Example

For example uint256, bool, string, bytes1 or address.

Tip

Instead of working with the name, it may be better to use the type property.

Returns:

Type Description
str

Name of the elementary type.

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

When the parent is a NewExpression, this can only be bytes or string.

Returns:

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

Parent IR node.

state_mutability: Optional[StateMutability] property #

Is only set for address as either StateMutability.PAYABLE or StateMutability.NONPAYABLE.

Returns:

Type Description
Optional[StateMutability]

State mutability of the address type.

type: Union[Address, Bool, Int, UInt, Fixed, UFixed, String, Bytes, FixedBytes, Type] property #

Returns either the generic Type expression type (this is the case of a type conversion, for example address(0)) or directly one of the elementary expression types.

Returns:

Type Description
Union[Address, Bool, Int, UInt, Fixed, UFixed, String, Bytes, FixedBytes, Type]

Type description.