Struct Ty 

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

Implementations

impl Ty<'static>

pub fn ingredient(zalsa: &Zalsa) -> &IngredientImpl<Ty<'static>>

impl<'db> Ty<'db>

pub fn new_<Db_, T0>(db: &'db Db_, kind_: T0) -> Ty<'db>

where T0: Lookup<InternedWrapperNoDebug<WithCachedTypeInfo<TyKind<DbInterner<'db>>>>> + Hash, Db_: Database + ?Sized, InternedWrapperNoDebug<WithCachedTypeInfo<TyKind<DbInterner<'db>>>>: HashEqLike<T0>,

impl Ty<'_>

pub fn default_debug_fmt( this: Ty<'_>, f: &mut Formatter<'_>, ) -> Result<(), Error>

where InternedWrapperNoDebug<WithCachedTypeInfo<TyKind<DbInterner<'db>>>>: for<'db> Debug,

Default debug formatting for this struct (may be useful if you define your own Debug impl)

impl<'db> Ty<'db>

pub fn new(interner: DbInterner<'db>, kind: TyKind<DbInterner<'db>>) -> Ty<'db>

pub fn inner(&self) -> &WithCachedTypeInfo<TyKind<DbInterner<'db>>>

pub fn new_adt( interner: DbInterner<'db>, adt_id: AdtId, args: GenericArgs<'db>, ) -> Ty<'db>

pub fn new_param( interner: DbInterner<'db>, id: TypeParamId, index: u32, ) -> Ty<'db>

pub fn new_placeholder( interner: DbInterner<'db>, placeholder: Placeholder<BoundTy>, ) -> Ty<'db>

pub fn new_infer(interner: DbInterner<'db>, infer: InferTy) -> Ty<'db>

pub fn new_int_var(interner: DbInterner<'db>, v: IntVid) -> Ty<'db>

pub fn new_float_var(interner: DbInterner<'db>, v: FloatVid) -> Ty<'db>

pub fn new_int(interner: DbInterner<'db>, i: IntTy) -> Ty<'db>

pub fn new_uint(interner: DbInterner<'db>, ui: UintTy) -> Ty<'db>

pub fn new_float(interner: DbInterner<'db>, f: FloatTy) -> Ty<'db>

pub fn new_fresh(interner: DbInterner<'db>, n: u32) -> Ty<'db>

pub fn new_fresh_int(interner: DbInterner<'db>, n: u32) -> Ty<'db>

pub fn new_fresh_float(interner: DbInterner<'db>, n: u32) -> Ty<'db>

pub fn new_empty_tuple(interner: DbInterner<'db>) -> Ty<'db>

pub fn new_imm_ptr(interner: DbInterner<'db>, ty: Ty<'db>) -> Ty<'db>

pub fn new_imm_ref( interner: DbInterner<'db>, region: Region<'db>, ty: Ty<'db>, ) -> Ty<'db>

pub fn new_opaque( interner: DbInterner<'db>, def_id: SolverDefId, args: GenericArgs<'db>, ) -> Ty<'db>

pub fn primitive_size(self, interner: DbInterner<'db>) -> Size

Returns the Size for primitive types (bool, uint, int, char, float).

pub fn int_size_and_signed(self, interner: DbInterner<'db>) -> (Size, bool)

pub fn walk(self) -> TypeWalker<DbInterner<'db>>

pub fn has_trivial_sizedness( self, tcx: DbInterner<'db>, sizedness: SizedTraitKind, ) -> bool

Fast path helper for testing if a type is Sized or MetaSized.

Returning true means the type is known to implement the sizedness trait. Returning false means nothing – could be sized, might not be.

Note that we could never rely on the fact that a type such as [_] is trivially !Sized because we could be in a type environment with a bound such as [_]: Copy. A function with such a bound obviously never can be called, but that doesn’t mean it shouldn’t typecheck. This is why this method doesn’t return Option<bool>.

pub fn is_trivially_pure_clone_copy(self) -> bool

Fast path helper for primitives which are always Copy and which have a side-effect-free Clone impl.

Returning true means the type is known to be pure and Copy+Clone. Returning false means nothing – could be Copy, might not be.

This is mostly useful for optimizations, as these are the types on which we can replace cloning with dereferencing.

pub fn is_trivially_wf(self, tcx: DbInterner<'db>) -> bool

pub fn is_never(self) -> bool

pub fn is_bool(self) -> bool

pub fn is_scalar(self) -> bool

A scalar type is one that denotes an atomic datum, with no sub-components. (A RawPtr is scalar because it represents a non-managed pointer, so its contents are abstract to rustc.)

pub fn is_infer(self) -> bool

pub fn is_numeric(self) -> bool

pub fn is_str(self) -> bool

pub fn is_unit(self) -> bool

pub fn is_raw_ptr(self) -> bool

pub fn is_array(self) -> bool

pub fn is_slice(self) -> bool

pub fn is_union(self) -> bool

pub fn boxed_ty(self) -> Option<Ty<'db>>

pub fn as_adt(self) -> Option<(AdtId, GenericArgs<'db>)>

pub fn ty_vid(self) -> Option<TyVid>

pub fn safe_to_unsafe_fn_ty( interner: DbInterner<'db>, sig: Binder<DbInterner<'db>, FnSig<DbInterner<'db>>>, ) -> Ty<'db>

Given a fn type, returns an equivalent unsafe fn type; that is, a fn type that is equivalent in every way for being unsafe.

pub fn builtin_deref(self, explicit: bool) -> Option<Ty<'db>>

Returns the type of *ty.

The parameter explicit indicates if this is an explicit dereference. Some types – notably raw ptrs – can only be dereferenced explicitly.

pub fn references_non_lt_error(self) -> bool

Whether the type contains some non-lifetime, aka. type or const, error type.

pub fn callable_sig( self, interner: DbInterner<'db>, ) -> Option<Binder<DbInterner<'db>, FnSig<DbInterner<'db>>>>

pub fn as_reference(self) -> Option<(Ty<'db>, Region<'db>, Mutability)>

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

pub fn as_tuple(self) -> Option<Tys<'db>>

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

pub fn strip_references(self) -> Ty<'db>

pub fn strip_reference(self) -> Ty<'db>

pub fn replace_infer_with_error(self, interner: DbInterner<'db>) -> Ty<'db>

Replace infer vars with errors.

This needs to be called for every type that may contain infer vars and is yielded to outside inference, as things other than inference do not expect to see infer vars.

pub fn from_builtin_type(interner: DbInterner<'db>, ty: BuiltinType) -> Ty<'db>

pub fn as_builtin(self) -> Option<BuiltinType>

pub fn impl_trait_bounds( self, db: &'db (dyn HirDatabase + 'static), ) -> Option<Vec<Clause<'db>>>

pub fn equals_ctor(self, other: Ty<'db>) -> bool

FIXME: Get rid of this, it’s not a good abstraction

Trait Implementations

impl<'db> Clone for Ty<'db>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'db> Debug for Ty<'db>

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

Formats the value using the given formatter.

impl<'db> Flags for Ty<'db>

fn flags(&self) -> TypeFlags

fn outer_exclusive_binder(&self) -> DebruijnIndex

impl<'db> From<Ty<'db>> for GenericArg<'db>

fn from(value: Ty<'db>) -> GenericArg<'db>

Converts to this type from the input type.

impl<'db> From<Ty<'db>> for Term<'db>

fn from(value: Ty<'db>) -> Term<'db>

Converts to this type from the input type.

impl<'db> Hash for Ty<'db>

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<'db> HirDisplay<'db> for Ty<'db>

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

fn into_displayable<'a>( &'a self, db: &'db (dyn HirDatabase + 'static), max_size: Option<usize>, limited_size: Option<usize>, omit_verbose_types: bool, display_target: DisplayTarget, display_kind: DisplayKind, closure_style: ClosureStyle, show_container_bounds: bool, ) -> HirDisplayWrapper<'a, 'db, Self>

where Self: Sized,

Returns a Displayable type that is human-readable.

fn display<'a>( &'a self, db: &'db (dyn HirDatabase + 'static), display_target: DisplayTarget, ) -> HirDisplayWrapper<'a, 'db, 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: &'db (dyn HirDatabase + 'static), max_size: Option<usize>, display_target: DisplayTarget, ) -> HirDisplayWrapper<'a, 'db, 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_limited<'a>( &'a self, db: &'db (dyn HirDatabase + 'static), limited_size: Option<usize>, display_target: DisplayTarget, ) -> HirDisplayWrapper<'a, 'db, Self>

where Self: Sized,

Returns a Displayable type that is human-readable and tries to limit the number of items inside. Use this for showing definitions which may contain too many items, like trait, struct, enum

fn display_source_code<'a>( &'a self, db: &'db (dyn HirDatabase + 'static), module_id: ModuleIdLt<'static>, allow_opaque: bool, ) -> 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: &'db (dyn HirDatabase + 'static), display_target: DisplayTarget, ) -> HirDisplayWrapper<'a, 'db, Self>

where Self: Sized,

Returns a String representation of self for test purposes

fn display_with_container_bounds<'a>( &'a self, db: &'db (dyn HirDatabase + 'static), show_container_bounds: bool, display_target: DisplayTarget, ) -> HirDisplayWrapper<'a, 'db, Self>

where Self: Sized,

Returns a String representation of self that shows the constraint from the container for functions

impl<'db> IntoKind for Ty<'db>

type Kind = TyKind<DbInterner<'db>>

fn kind(self) -> <Ty<'db> as IntoKind>::Kind

impl<'db> PartialEq for Ty<'db>

fn eq(&self, other: &Ty<'db>) -> 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<'db> Relate<DbInterner<'db>> for Ty<'db>

fn relate<R>( relation: &mut R, a: Ty<'db>, b: Ty<'db>, ) -> Result<Ty<'db>, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> ToTrace<'db> for Ty<'db>

fn to_trace(cause: &ObligationCause, a: Ty<'db>, b: Ty<'db>) -> TypeTrace<'db>

impl<'db> Ty<DbInterner<'db>> for Ty<'db>

fn new_unit(interner: DbInterner<'db>) -> Ty<'db>

fn new_bool(interner: DbInterner<'db>) -> Ty<'db>

fn new_u8(interner: DbInterner<'db>) -> Ty<'db>

fn new_usize(interner: DbInterner<'db>) -> Ty<'db>

fn new_infer(interner: DbInterner<'db>, var: InferTy) -> Ty<'db>

fn new_var(interner: DbInterner<'db>, var: TyVid) -> Ty<'db>

fn new_param(interner: DbInterner<'db>, param: ParamTy) -> Ty<'db>

fn new_placeholder( interner: DbInterner<'db>, param: Placeholder<BoundTy>, ) -> Ty<'db>

fn new_bound( interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundTy, ) -> Ty<'db>

fn new_anon_bound( interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundVar, ) -> Ty<'db>

fn new_canonical_bound(interner: DbInterner<'db>, var: BoundVar) -> Ty<'db>

fn new_alias( interner: DbInterner<'db>, kind: AliasTyKind, alias_ty: AliasTy<DbInterner<'db>>, ) -> Ty<'db>

fn new_error(interner: DbInterner<'db>, guar: ErrorGuaranteed) -> Ty<'db>

fn new_adt( interner: DbInterner<'db>, adt_def: <DbInterner<'db> as Interner>::AdtDef, args: GenericArgs<'db>, ) -> Ty<'db>

fn new_foreign(interner: DbInterner<'db>, def_id: TypeAliasIdWrapper) -> Ty<'db>

fn new_dynamic( interner: DbInterner<'db>, preds: <DbInterner<'db> as Interner>::BoundExistentialPredicates, region: <DbInterner<'db> as Interner>::Region, ) -> Ty<'db>

fn new_coroutine( interner: DbInterner<'db>, def_id: CoroutineIdWrapper, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_coroutine_closure( interner: DbInterner<'db>, def_id: CoroutineIdWrapper, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_closure( interner: DbInterner<'db>, def_id: ClosureIdWrapper, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_coroutine_witness( interner: DbInterner<'db>, def_id: CoroutineIdWrapper, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_coroutine_witness_for_coroutine( interner: DbInterner<'db>, def_id: CoroutineIdWrapper, coroutine_args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_ptr(interner: DbInterner<'db>, ty: Ty<'db>, mutbl: Mutability) -> Ty<'db>

fn new_ref( interner: DbInterner<'db>, region: <DbInterner<'db> as Interner>::Region, ty: Ty<'db>, mutbl: Mutability, ) -> Ty<'db>

fn new_array_with_const_len( interner: DbInterner<'db>, ty: Ty<'db>, len: <DbInterner<'db> as Interner>::Const, ) -> Ty<'db>

fn new_slice(interner: DbInterner<'db>, ty: Ty<'db>) -> Ty<'db>

fn new_tup( interner: DbInterner<'db>, tys: &[<DbInterner<'db> as Interner>::Ty], ) -> Ty<'db>

fn new_tup_from_iter<It, T>( interner: DbInterner<'db>, iter: It, ) -> <T as CollectAndApply<Ty<'db>, Ty<'db>>>::Output

where It: Iterator<Item = T>, T: CollectAndApply<Ty<'db>, Ty<'db>>,

fn new_fn_def( interner: DbInterner<'db>, def_id: CallableIdWrapper, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_fn_ptr( interner: DbInterner<'db>, sig: Binder<DbInterner<'db>, FnSig<DbInterner<'db>>>, ) -> Ty<'db>

fn new_pat( interner: DbInterner<'db>, ty: Ty<'db>, pat: <DbInterner<'db> as Interner>::Pat, ) -> Ty<'db>

fn new_unsafe_binder( interner: DbInterner<'db>, ty: Binder<DbInterner<'db>, <DbInterner<'db> as Interner>::Ty>, ) -> Ty<'db>

fn tuple_fields(self) -> <DbInterner<'db> as Interner>::Tys

fn to_opt_closure_kind(self) -> Option<ClosureKind>

fn from_closure_kind(interner: DbInterner<'db>, kind: ClosureKind) -> Ty<'db>

fn from_coroutine_closure_kind( interner: DbInterner<'db>, kind: ClosureKind, ) -> Ty<'db>

fn has_unsafe_fields(self) -> bool

Checks whether this type is an ADT that has unsafe fields.

fn discriminant_ty( self, interner: DbInterner<'db>, ) -> <DbInterner<'db> as Interner>::Ty

fn new_projection_from_args( interner: I, def_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> Self

fn new_projection( interner: I, def_id: <I as Interner>::DefId, args: impl IntoIterator>, ) -> Self

where <impl IntoIterator as IntoIterator>::Item: Into<<I as Interner>::GenericArg>,

fn is_ty_var(self) -> bool

fn is_ty_error(self) -> bool

fn is_floating_point(self) -> bool

fn is_integral(self) -> bool

fn is_fn_ptr(self) -> bool

fn fn_sig(self, interner: I) -> Binder<I, FnSig<I>>

fn is_known_rigid(self) -> bool

fn is_guaranteed_unsized_raw(self) -> bool

impl<'db> TypeFoldable<DbInterner<'db>> for Ty<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Ty<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Ty<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeSuperFoldable<DbInterner<'db>> for Ty<'db>

fn try_super_fold_with<F>( self, folder: &mut F, ) -> Result<Ty<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

Provides a default fold for a recursive type of interest. This should only be called within TypeFolder methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyFolder::try_fold_ty(ty), it is valid to call ty.try_super_fold_with(self), but any other folding should be done with xyz.try_fold_with(self).

fn super_fold_with<F>(self, folder: &mut F) -> Ty<'db>

where F: TypeFolder<DbInterner<'db>>,

A convenient alternative to try_super_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_super_fold_with.

impl<'db> TypeSuperVisitable<DbInterner<'db>> for Ty<'db>

fn super_visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

Provides a default visit for a recursive type of interest. This should only be called within TypeVisitor methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyVisitor::visit_ty(ty), it is valid to call ty.super_visit_with(self), but any other visiting should be done with xyz.visit_with(self).

impl<'db> TypeVisitable<DbInterner<'db>> for Ty<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> Update for Ty<'db>

unsafe fn maybe_update(old_pointer: *mut Ty<'db>, new_value: Ty<'db>) -> bool

Returns

impl<'db> Copy for Ty<'db>

impl<'db> Eq for Ty<'db>

impl<'db> Send for Ty<'db>

impl<'db> StructuralPartialEq for Ty<'db>

impl<'db> Sync for Ty<'db>