Struct Ty 

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

Implementations

impl Ty<'static>

pub fn ingredient(zalsa: &Zalsa) -> &IngredientImpl<Self>

impl<'db> Ty<'db>

pub fn new_<Db_, T0: Lookup<InternedWrapperNoDebug<WithCachedTypeInfo<TyKind<'db>>>> + Hash>( db: &'db Db_, kind_: T0, ) -> Self

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

impl Ty<'_>

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

where for<'db> InternedWrapperNoDebug<WithCachedTypeInfo<TyKind<'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<'db>) -> Self

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

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

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

pub fn new_placeholder( interner: DbInterner<'db>, placeholder: PlaceholderTy, ) -> Self

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

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

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

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

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

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

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

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

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

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

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

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

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

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: PolyFnSig<'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<'db, FnSig<'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, ) -> 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> AsId for Ty<'db>

fn as_id(&self) -> Id

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 Configuration for Ty<'static>

const LOCATION: Location

const DEBUG_NAME: &'static str = "Ty"

const PERSIST: bool = false

Whether this struct should be persisted with the database.

type Fields<'a> = (InternedWrapperNoDebug<WithCachedTypeInfo<TyKind<DbInterner<'a>>>>,)

The fields of the struct being interned.

type Struct<'db> = Ty<'db>

The end user struct

fn serialize<S: Serializer>( fields: &Self::Fields<'_>, serializer: S, ) -> Result<S::Ok, S::Error>

Serialize the fields using serde.

fn deserialize<'de, D: Deserializer<'de>>( deserializer: D, ) -> Result<Self::Fields<'static>, D::Error>

Deserialize the fields using serde.

const REVISIONS: NonZero<usize> = _

fn heap_size(_value: &Self::Fields<'_>) -> Option<usize>

Returns the size of any heap allocations in the output value, in bytes.

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

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

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>) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<'db> FromId for Ty<'db>

fn from_id(id: Id) -> Self

impl<'db> HasJar for Ty<'db>

const KIND: JarKind = zalsa_::JarKind::Struct

The [JarKind] for Self::Jar.

type Jar = JarImpl<Ty<'static>>

The [Jar] associated with this ingredient.

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

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

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

fn into_displayable<'a>( &'a self, db: &'db dyn HirDatabase, 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, 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, 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, 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, module_id: ModuleId, 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, 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, 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) -> Self::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: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

impl<'db> SalsaStructInDb for Ty<'db>

type MemoIngredientMap = MemoIngredientSingletonIndex

fn lookup_ingredient_index(aux: &Zalsa) -> IngredientIndices

Lookup or create ingredient indices.

fn entries(zalsa: &Zalsa) -> impl Iterator<Item = DatabaseKeyIndex> + '_

Returns the IDs of any instances of this struct in the database.

fn cast(id: Id, type_id: TypeId) -> Option<Self>

Plumbing to support nested salsa supertypes.

unsafe fn memo_table( zalsa: &Zalsa, id: Id, current_revision: Revision, ) -> MemoTableWithTypes<'_>

Return the memo table associated with id.

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

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

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

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

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

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

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

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

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

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

fn new_placeholder(interner: DbInterner<'db>, param: PlaceholderTy) -> Self

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

where It: Iterator<Item = T>, T: CollectAndApply<Self, Self>,

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

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

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

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

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) -> Self

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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: TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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 Self, new_value: Self) -> 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>