Struct Ty 

pub struct Ty<'gcx>(/* private fields */);

An interned type.

Implementations

impl<'gcx> Ty<'gcx>

pub fn new(gcx: Gcx<'gcx>, kind: TyKind<'gcx>) -> Ty<'gcx>

pub fn display(self, gcx: Gcx<'gcx>) -> impl Display + use<'gcx>

Displays the type for human-readable diagnostics.

pub fn with_loc(self, gcx: Gcx<'gcx>, loc: DataLocation) -> Ty<'gcx>

pub fn with_loc_if_ref(self, gcx: Gcx<'gcx>, loc: DataLocation) -> Ty<'gcx>

pub fn with_loc_if_ref_opt( self, gcx: Gcx<'gcx>, loc: Option<DataLocation>, ) -> Ty<'gcx>

pub fn loc(self) -> Option<DataLocation>

Returns the location of the type if it is a reference.

pub fn peel_refs(self) -> Ty<'gcx>

Peels Ref layers from the type, returning the inner type.

pub fn as_externally_callable_function( self, in_library: bool, gcx: Gcx<'gcx>, ) -> Ty<'gcx>

pub fn as_attached_function(self, gcx: Gcx<'gcx>) -> Ty<'gcx>

pub fn make_ref(self, gcx: Gcx<'gcx>, loc: DataLocation) -> Ty<'gcx>

pub fn make_type_type(self, gcx: Gcx<'gcx>) -> Ty<'gcx>

pub fn make_meta(self, gcx: Gcx<'gcx>) -> Ty<'gcx>

pub fn is_ref(self) -> bool

Returns true if the type is a reference.

pub fn is_ref_at(self, loc: DataLocation) -> bool

Returns true if the type is a reference to the given location.

pub fn data_stored_in(self, loc: DataLocation) -> bool

Returns true if the type is a reference to the given location.

pub fn is_value_type(self) -> bool

Returns true if the type is a value type.

Reference: https://docs.soliditylang.org/en/latest/types.html#value-types

pub fn is_reference_type(self) -> bool

Returns true if the type is a reference type.

pub fn is_recursive(self, gcx: Gcx<'gcx>) -> bool

Returns true if the type is recursive.

pub fn has_mapping(self, gcx: Gcx<'gcx>) -> bool

Returns true if this type contains a mapping.

pub fn contains_library(self, gcx: Gcx<'gcx>) -> bool

Returns true if this type contains a library contract type.

pub fn has_internal_function(self) -> bool

Returns true if this type contains a non-public (internal/private) function type.

pub fn error_reported(self) -> Result<(), ErrorGuaranteed>

Returns Err(guar) if this type contains an error.

pub fn references_error(self) -> bool

Returns true if this type contains an error.

pub fn can_be_exported(self, gcx: Gcx<'gcx>) -> bool

Returns true if this type can be part of an externally callable function.

pub fn parameters(self) -> Option<&'gcx [Ty<'gcx>]>

Returns the parameter types of the type.

pub fn returns(self) -> Option<&'gcx [Ty<'gcx>]>

Returns the return types of the type.

pub fn state_mutability(self) -> Option<StateMutability>

Returns the state mutability of the type.

pub fn function_id(self) -> Option<FunctionId>

Returns the function ID if this is a function type with a specific function.

pub fn item_id(self) -> Option<ItemId>

Returns the HIR item ID associated with this type, if any.

pub fn item_source(self, gcx: Gcx<'gcx>) -> Option<SourceId>

Returns the source ID where this type’s HIR item is defined.

pub fn visit<T>( self, f: &mut impl FnMut(Ty<'gcx>) -> ControlFlow<T>, ) -> ControlFlow<T>

Visits the type and its subtypes.

pub fn is_array(self) -> bool

Returns true if the type is an array.

pub fn is_array_like(&self) -> bool

Returns true if the type is an array-like type.

This is either an array or bytes/string.

pub fn is_sliceable(self) -> bool

Returns true if the type is sliceable.

This is either an array, bytes, string, or slice.

pub fn is_dynamically_sized(self) -> bool

Returns true if the type is dynamically sized.

pub fn is_dynamically_encoded(self, gcx: Gcx<'gcx>) -> bool

pub fn is_fixed_bytes(self) -> bool

Returns true if the type is a fixed-size byte array.

pub fn is_integer(self) -> bool

Returns true if the type is an integer, including literals.

pub fn is_signed(self) -> bool

Returns true if the type is a signed integer, including negative literals.

pub fn is_tuple(self) -> bool

Returns true if the type is a tuple.

pub fn is_unit(self) -> bool

Returns true if the type is the unit type ().

pub fn nameable(self) -> bool

Returns true if the type can be used for variables.

pub fn common_type(self, b: Ty<'gcx>, gcx: Gcx<'gcx>) -> Option<Ty<'gcx>>

Returns the common type between the two types.

pub fn base_type(self, gcx: Gcx<'gcx>) -> Option<Ty<'gcx>>

Returns the base type, if any.

pub fn convert_implicit_to(self, other: Ty<'gcx>, gcx: Gcx<'gcx>) -> bool

Returns true if the type is implicitly convertible to the given type.

Prefer using Ty::try_convert_implicit_to if you need to handle the error case.

pub fn try_convert_implicit_to( self, other: Ty<'gcx>, gcx: Gcx<'gcx>, ) -> Result<(), TyConvertError>

Checks if the type is implicitly convertible to the given type.

See: https://docs.soliditylang.org/en/latest/types.html#implicit-conversions

pub fn convert_explicit_to(self, other: Ty<'gcx>, gcx: Gcx<'gcx>) -> bool

Returns true if the type is explicitly convertible to the given type.

Prefer using Ty::try_convert_explicit_to if you need to handle the error case.

pub fn try_convert_explicit_to( self, other: Ty<'gcx>, gcx: Gcx<'gcx>, ) -> Result<Ty<'gcx>, TyConvertError>

Performs an explicit type conversion, returning the result type.

For most conversions this is other, but for bytes <-> string with unlocated target, the result type inherits the source’s data location.

See: https://docs.soliditylang.org/en/latest/types.html#explicit-conversions

pub fn mobile(self, gcx: Gcx<'gcx>) -> Option<Ty<'gcx>>

Returns the mobile (in contrast to static) type corresponding to the given type.

Trait Implementations

impl<'gcx> Clone for Ty<'gcx>

fn clone(&self) -> Ty<'gcx>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'gcx> Copy for Ty<'gcx>

impl Debug for Ty<'_>

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

Formats the value using the given formatter.

impl<'gcx> Deref for Ty<'gcx>

type Target = &'gcx TyData<'gcx>

The resulting type after dereferencing.

fn deref(&self) -> &<Ty<'gcx> as Deref>::Target

Dereferences the value.

impl<'gcx> Eq for Ty<'gcx>

impl<'gcx> Hash for Ty<'gcx>

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

where __H: Hasher,

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 Ty<'gcx>

fn eq(&self, other: &Ty<'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> StructuralPartialEq for Ty<'gcx>