Enum ra_ap_hir_ty::Ty

pub enum Ty {
    Adt(AdtId<Interner>, Substs),
    AssociatedType(TypeAliasId, Substs),
    Scalar(Scalar),
    Tuple(usize, Substs),
    Array(Substs),
    Slice(Substs),
    Raw(Mutability, Substs),
    Ref(Mutability, Substs),
    OpaqueType(OpaqueTyId, Substs),
    FnDef(CallableDefId, Substs),
    Str,
    Never,
    Closure(DefWithBodyId, ExprId, Substs),
    ForeignType(TypeAliasId),
    Function(FnPointer),
    Alias(AliasTy),
    Placeholder(TypeParamId),
    BoundVar(BoundVar),
    InferenceVar(InferenceVar, TyVariableKind),
    Dyn(Arc<[GenericPredicate]>),
    Unknown,
}

A type.

See also the TyKind enum in rustc (librustc/ty/sty.rs), which represents the same thing (but in a different way).

This should be cheap to clone.

Variants

Adt(AdtId<Interner>, Substs)

Structures, enumerations and unions.

AssociatedType(TypeAliasId, Substs)

Represents an associated item like Iterator::Item. This is used when we have tried to normalize a projection like T::Item but couldn’t find a better representation. In that case, we generate an application type like (Iterator::Item)<T>.

Scalar(Scalar)

a scalar type like bool or u32

Tuple(usize, Substs)

A tuple type. For example, (i32, bool).

Array(Substs)

An array with the given length. Written as [T; n].

Slice(Substs)

The pointee of an array slice. Written as [T].

Raw(Mutability, Substs)

A raw pointer. Written as *mut T or *const T

Ref(Mutability, Substs)

A reference; a pointer with an associated lifetime. Written as &'a mut T or &'a T.

OpaqueType(OpaqueTyId, Substs)

This represents a placeholder for an opaque type in situations where we don’t know the hidden type (i.e. currently almost always). This is analogous to the AssociatedType type constructor. It is also used as the type of async block, with one type parameter representing the Future::Output type.

FnDef(CallableDefId, Substs)

The anonymous type of a function declaration/definition. Each function has a unique type, which is output (for a function named foo returning an i32) as fn() -> i32 {foo}.

This includes tuple struct / enum variant constructors as well.

For example the type of bar here:

fn foo() -> i32 { 1 }
let bar = foo; // bar: fn() -> i32 {foo}

Str

The pointee of a string slice. Written as str.

Never

The never type !.

Closure(DefWithBodyId, ExprId, Substs)

The type of a specific closure.

The closure signature is stored in a FnPtr type in the first type parameter.

ForeignType(TypeAliasId)

Represents a foreign type declared in external blocks.

Function(FnPointer)

A pointer to a function. Written as fn() -> i32.

For example the type of bar here:

fn foo() -> i32 { 1 }
let bar: fn() -> i32 = foo;

Alias(AliasTy)

An “alias” type represents some form of type alias, such as:

• An associated type projection like <T as Iterator>::Item
• impl Trait types
• Named type aliases like type Foo<X> = Vec<X>

Placeholder(TypeParamId)

A placeholder for a type parameter; for example, T in fn f<T>(x: T) {} when we’re type-checking the body of that function. In this situation, we know this stands for some type, but don’t know the exact type.

BoundVar(BoundVar)

A bound type variable. This is used in various places: when representing some polymorphic type like the type of function fn f<T>, the type parameters get turned into variables; during trait resolution, inference variables get turned into bound variables and back; and in Dyn the Self type is represented with a bound variable as well.

InferenceVar(InferenceVar, TyVariableKind)

A type variable used during type checking.

Dyn(Arc<[GenericPredicate]>)

A trait object (dyn Trait or bare Trait in pre-2018 Rust).

The predicates are quantified over the Self type, i.e. Ty::Bound(0) represents the Self type inside the bounds. This is currently implicit; Chalk has the Binders struct to make it explicit, but it didn’t seem worth the overhead yet.

Unknown

A placeholder for a type which could not be computed; this is propagated to avoid useless error messages. Doubles as a placeholder where type variables are inserted before type checking, since we want to try to infer a better type here anyway – for the IDE use case, we want to try to infer as much as possible even in the presence of type errors.

Implementations

impl Ty

pub fn def_crates(
    &self,
    db: &dyn HirDatabase,
    cur_crate: CrateId
) -> Option<ArrayVec<[CrateId; 2]>>

impl Ty

pub fn from_hir(ctx: &TyLoweringContext<'_>, type_ref: &TypeRef) -> Self

pub fn from_hir_ext(
    ctx: &TyLoweringContext<'_>,
    type_ref: &TypeRef
) -> (Self, Option<TypeNs>)

impl Ty

pub fn unit() -> Self

pub fn adt_ty(adt: AdtId, substs: Substs) -> Ty

pub fn fn_ptr(sig: CallableSig) -> Self

pub fn builtin(builtin: BuiltinType) -> Self

pub fn as_reference(&self) -> Option<(&Ty, Mutability)>

pub fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)>

pub fn strip_references(&self) -> &Ty

pub fn as_adt(&self) -> Option<(AdtId, &Substs)>

pub fn as_tuple(&self) -> Option<&Substs>

pub fn as_generic_def(&self) -> Option<GenericDefId>

pub fn is_never(&self) -> bool

pub fn is_unknown(&self) -> bool

pub fn equals_ctor(&self, other: &Ty) -> bool

pub fn dyn_trait_ref(&self) -> Option<&TraitRef>

If this is a dyn Trait type, this returns the Trait part.

pub fn dyn_trait(&self) -> Option<TraitId>

If this is a dyn Trait, returns that trait.

pub fn as_fn_def(&self) -> Option<FunctionId>

pub fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig>

pub fn apply_substs(self, new_substs: Substs) -> Ty

If this is a type with type parameters (an ADT or function), replaces the Substs for these type parameters with the given ones. (So e.g. if self is Option<_> and the substs contain u32, we’ll have Option<u32> afterwards.)

pub fn substs(&self) -> Option<&Substs>

Returns the type parameters of this type if it has some (i.e. is an ADT or function); so if self is Option<u32>, this returns the u32.

pub fn substs_mut(&mut self) -> Option<&mut Substs>

pub fn impl_trait_bounds(
    &self,
    db: &dyn HirDatabase
) -> Option<Vec<GenericPredicate>>

pub fn associated_type_parent_trait(
    &self,
    db: &dyn HirDatabase
) -> Option<TraitId>

Trait Implementations

impl Clone for Ty

fn clone(&self) -> Ty

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ty

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

Formats the value using the given formatter.

impl Eq for Ty

impl Hash for Ty

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl HirDisplay for &Ty

fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError>

fn into_displayable<'a>(
    &'a self,
    db: &'a dyn HirDatabase,
    max_size: Option<usize>,
    omit_verbose_types: bool,
    display_target: DisplayTarget
) -> HirDisplayWrapper<'a, Self> where
    Self: Sized, 

Returns a Displayable type that is human-readable.

fn display<'a>(&'a self, db: &'a dyn HirDatabase) -> HirDisplayWrapper<'a, Self> where
    Self: Sized, 

Returns a Displayable type that is human-readable. Use this for showing types to the user (e.g. diagnostics)

fn display_truncated<'a>(
    &'a self,
    db: &'a dyn HirDatabase,
    max_size: Option<usize>
) -> HirDisplayWrapper<'a, Self> where
    Self: Sized, 

Returns a Displayable type that is human-readable and tries to be succinct. Use this for showing types to the user where space is constrained (e.g. doc popups)

fn display_source_code<'a>(
    &'a self,
    db: &'a dyn HirDatabase,
    module_id: ModuleId
) -> Result<String, DisplaySourceCodeError>

Returns a String representation of self that can be inserted into the given module. Use this when generating code (e.g. assists)

fn display_test<'a>(
    &'a self,
    db: &'a dyn HirDatabase
) -> HirDisplayWrapper<'a, Self> where
    Self: Sized, 

Returns a String representation of self for test purposes

impl HirDisplay for Ty

fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError>

fn into_displayable<'a>(
    &'a self,
    db: &'a dyn HirDatabase,
    max_size: Option<usize>,
    omit_verbose_types: bool,
    display_target: DisplayTarget
) -> HirDisplayWrapper<'a, Self> where
    Self: Sized, 

Returns a Displayable type that is human-readable.

fn display<'a>(&'a self, db: &'a dyn HirDatabase) -> HirDisplayWrapper<'a, Self> where
    Self: Sized, 

Returns a Displayable type that is human-readable. Use this for showing types to the user (e.g. diagnostics)

fn display_truncated<'a>(
    &'a self,
    db: &'a dyn HirDatabase,
    max_size: Option<usize>
) -> HirDisplayWrapper<'a, Self> where
    Self: Sized, 

Returns a Displayable type that is human-readable and tries to be succinct. Use this for showing types to the user where space is constrained (e.g. doc popups)

fn display_source_code<'a>(
    &'a self,
    db: &'a dyn HirDatabase,
    module_id: ModuleId
) -> Result<String, DisplaySourceCodeError>

Returns a String representation of self that can be inserted into the given module. Use this when generating code (e.g. assists)

fn display_test<'a>(
    &'a self,
    db: &'a dyn HirDatabase
) -> HirDisplayWrapper<'a, Self> where
    Self: Sized, 

Returns a String representation of self for test purposes

impl PartialEq<Ty> for Ty

fn eq(&self, other: &Ty) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralEq for Ty

impl StructuralPartialEq for Ty

impl TypeWalk for Ty

fn walk(&self, f: &mut impl FnMut(&Ty))

fn walk_mut_binders(
    &mut self,
    f: &mut impl FnMut(&mut Ty, DebruijnIndex),
    binders: DebruijnIndex
)

Walk the type, counting entered binders.

fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty))

fn fold_binders(
    self,
    f: &mut impl FnMut(Ty, DebruijnIndex) -> Ty,
    binders: DebruijnIndex
) -> Self where
    Self: Sized, 

fn fold(self, f: &mut impl FnMut(Ty) -> Ty) -> Self where
    Self: Sized, 

fn subst_bound_vars(self, substs: &Substs) -> Self where
    Self: Sized, 

Substitutes Ty::Bound vars with the given substitution.

fn subst_bound_vars_at_depth(
    self,
    substs: &Substs,
    depth: DebruijnIndex
) -> Self where
    Self: Sized, 

Substitutes Ty::Bound vars with the given substitution.

fn shift_bound_vars(self, n: DebruijnIndex) -> Self where
    Self: Sized, 

Shifts up debruijn indices of Ty::Bound vars by n.