Enum TyKind

#[non_exhaustive]
pub enum TyKind<'gcx> {
    Elementary(ElementaryType),
    StringLiteral(bool, TypeSize),
    IntLiteral(TypeSize),
    Ref(Ty<'gcx>, DataLocation),
    DynArray(Ty<'gcx>),
    Array(Ty<'gcx>, U256),
    Tuple(&'gcx [Ty<'gcx>]),
    Mapping(Ty<'gcx>, Ty<'gcx>),
    FnPtr(&'gcx TyFnPtr<'gcx>),
    Contract(ContractId),
    Struct(StructId),
    Enum(EnumId),
    Error(&'gcx [Ty<'gcx>], ErrorId),
    Event(&'gcx [Ty<'gcx>], EventId),
    Udvt(Ty<'gcx>, UdvtId),
    Module(SourceId),
    BuiltinModule(Builtin),
    Type(Ty<'gcx>),
    Meta(Ty<'gcx>),
    Err(ErrorGuaranteed),
}

The kind of a type.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Elementary(ElementaryType)

An elementary/primitive type.

StringLiteral(bool, TypeSize)

Any string literal. Contains (is_valid_utf8(s), min(s.len(), 32)).

• all string literals can coerce to bytes
• only valid UTF-8 string literals can coerce to string
• only string literals with len <= N can coerce to bytesN

IntLiteral(TypeSize)

Any integer or fixed-point number literal. Contains min(s.len(), 32).

Ref(Ty<'gcx>, DataLocation)

A reference to another type which lives in the data location.

DynArray(Ty<'gcx>)

Dynamic array: T[].

Array(Ty<'gcx>, U256)

Fixed-size array: T[N].

Tuple(&'gcx [Ty<'gcx>])

Tuple: (T1, T2, ...).

Mapping(Ty<'gcx>, Ty<'gcx>)

Mapping: mapping(K => V).

FnPtr(&'gcx TyFnPtr<'gcx>)

Function pointer: function(...) returns (...).

Contract(ContractId)

Contract.

Struct(StructId)

A struct.

Cannot contain the types of its fields because it can be recursive.

Enum(EnumId)

An enum.

Error(&'gcx [Ty<'gcx>], ErrorId)

A custom error.

Event(&'gcx [Ty<'gcx>], EventId)

An event.

Udvt(Ty<'gcx>, UdvtId)

A user-defined value type. Ty can only be Elementary.

Module(SourceId)

A source imported as a module: import "path" as Module;.

BuiltinModule(Builtin)

Builtin module.

Type(Ty<'gcx>)

The self-referential type, e.g. Enum in Enum.Variant. Corresponds to TypeType in solc.

Meta(Ty<'gcx>)

The meta type: type(<inner_type>).

Err(ErrorGuaranteed)

An invalid type. Silences further errors.

Trait Implementations

impl<'gcx> Borrow<TyKind<'gcx>> for &TyData<'gcx>

fn borrow(&self) -> &TyKind<'gcx>

Immutably borrows from an owned value.

impl<'gcx> Debug for TyKind<'gcx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'gcx> Hash for TyKind<'gcx>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'gcx> PartialEq for TyKind<'gcx>

fn eq(&self, other: &TyKind<'gcx>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'gcx> Eq for TyKind<'gcx>

impl<'gcx> StructuralPartialEq for TyKind<'gcx>