Module ty

Defines how the compiler represents types internally.

Two important entities in this module are:

• rustc_middle::ty::Ty, used to represent the semantics of a type.
• rustc_middle::ty::TyCtxt, the central data structure in the compiler.

For more information, see “The ty module: representing types” in the rustc-dev-guide.

Re-exports

• pub use self::pattern::Pattern;
• pub use self::pattern::PatternKind;
• pub use self::trait_def::TraitDef;
• pub use rustc_type_ir::ConstKind::Bound as BoundCt;
• pub use rustc_type_ir::ConstKind::Error as ErrorCt;
• pub use rustc_type_ir::ConstKind::Expr as ExprCt;
• pub use rustc_type_ir::ConstKind::Infer as InferCt;
• pub use rustc_type_ir::ConstKind::Param as ParamCt;
• pub use rustc_type_ir::ConstKind::Placeholder as PlaceholderCt;
• pub use rustc_type_ir::ConstKind::Unevaluated;
• pub use rustc_type_ir::ConstKind::Value;
• pub use vtable::*;
• pub use self::AssocItemContainer::*;
• pub use self::BorrowKind::*;
• pub use self::IntVarValue::*;
• pub use self::region::BoundRegionKind::*;

Modules

• abstract_const
  A subset of a mir body used for const evaluability checking.
• adjustment
• adt 🔒
• assoc 🔒
• cast
• closure 🔒
• codec
  This module contains some shared code for encoding and decoding various things from the ty module, and in particular implements support for “shorthands” which allow to have pointers back into the already encoded stream instead of re-encoding the same thing twice.
• consts 🔒
• context 🔒
  Type context book-keeping.
• data_structures
• diagnostics 🔒
  Diagnostics related methods for Ty.
• elaborate
• elaborate_impl 🔒
• erase_regions 🔒
• error
• fast_reject
• flags
• fold
• generic_args 🔒
• generics 🔒
• impls_ty 🔒
  This module contains HashStable implementations for various data types from rustc_middle::ty in no particular order.
• inhabitedness
  This module contains logic for determining whether a type is inhabited or uninhabited. The InhabitedPredicate type captures the minimum information needed to determine whether a type is inhabited given a ParamEnv and module ID.
• inherent
  Set of traits which are used to emulate the inherent impls that are present in rustc_middle. It is customary to glob-import rustc_type_ir::inherent::* to bring all of these traits into scope when programming in interner-agnostic settings, and to avoid importing any of these directly elsewhere (i.e. specify the full path for an implementation downstream).
• instance 🔒
• intrinsic 🔒
• ir_print
• lang_items
• layout
• lift
• list 🔒
• normalize_erasing_regions
  Methods for normalizing when you don’t care about regions (and aren’t doing type inference). If either of those things don’t apply to you, use infcx.normalize(...).
• opaque_types 🔒
• outlives
  The outlives relation T: 'a or 'a: 'b. This code frequently refers to rules defined in RFC 1214 (OutlivesFooBar), so see that RFC for reference.
• parameterized 🔒
• pattern
• predicate 🔒
• print
• region 🔒
• relate
• rvalue_scopes 🔒
• search_graph
• size_asserts 🔒
• solve
• structural_impls 🔒
  This module contains implementations of the Lift, TypeFoldable and TypeVisitable traits for various types in the Rust compiler. Most are written by hand, though we’ve recently added some macros and proc-macros to help with the tedium.
• sty 🔒
  This module contains TyKind and its major components.
• tls
• trait_def
• typeck_results 🔒
• util
  Miscellaneous type-system utilities that are too small to deserve their own modules.
• visit
• vtable
• walk
  An iterator over the type substructure. WARNING: this does not keep track of the region depth.

Macros

• try_visit

Structs

• AdtDef
• AdtDefData
  The definition of a user-defined type, e.g., a struct, enum, or union.
• AdtFlags
• AssocItem
  Information about an associated item
• AssocItems
  A list of ty::AssocItems in definition order that allows for efficient lookup by name.
• AsyncDestructor
• BoundConst
• BoundRegion
• BoundTy
• BoundVar
• CReaderCacheKey
• Canonical
  A “canonicalized” type V is one where all free inference variables have been rewritten to “canonical vars”. These are numbered starting from 0 in order of first appearance.
• CanonicalUserTypeAnnotation
• CanonicalVarInfo
  Information about a canonical variable that is included with the canonical value. This is sufficient information for code to create a copy of the canonical value in some other inference context, with fresh inference variables replacing the canonical values.
• CanonicalVarValues
  A set of values corresponding to the canonical variables from some Canonical. You can give these values to canonical_value.instantiate to instantiate them into the canonical value at the right places.
• CaptureInfo
  Part of MinCaptureInformationMap; describes the capture kind (&, &mut, move) for a particular capture as well as identifying the part of the source code that triggered this capture to occur.
• CapturedPlace
  A composite describing a Place that is captured by a closure.
• Clause
  A subset of predicates which can be assumed by the trait solver. They show up in an item’s where clauses, hence the name Clause, and may either be user-written (such as traits) or may be inserted during lowering.
• ClosureArgs
  A closure can be modeled as a struct that looks like:
• ClosureArgsParts
  Struct returned by split().
• ClosureSizeProfileData
• ClosureTypeInfo
• Const
• ConstInt
  A type for representing any integer. Only used for printing.
• ConstVid
  A const variable ID.
• CoroutineArgs
  Similar to ClosureArgs; see the above documentation for more.
• CoroutineArgsParts
• CoroutineClosureArgs
• CoroutineClosureArgsParts
  See docs for explanation of how each argument is used.
• CoroutineClosureSignature
• CrateInherentImpls
  A map for the local crate mapping each type to a vector of its inherent impls. This is not meant to be used outside of coherence; rather, you should request the vector for a specific type via tcx.inherent_impls(def_id) so as to minimize your dependencies (constructing this map requires touching the entire crate).
• CratePredicatesMap
  The crate outlives map is computed during typeck and contains the outlives of every item in the local crate. You should not use it directly, because to do so will make your pass dependent on the HIR of every item in the local crate. Instead, use tcx.inferred_outlives_of() to get the outlives for a particular item.
• CrateVariancesMap
  The crate variances map is computed during typeck and contains the variance of every item in the local crate. You should not use it directly, because to do so will make your pass dependent on the HIR of every item in the local crate. Instead, use tcx.variances_of() to get the variance for a particular item.
• CtxtInterners
• CurrentGcx
  This is used to get a reference to a GlobalCtxt if one is available.
• DebruijnIndex
  A De Bruijn index is a standard means of representing regions (and perhaps later types) in a higher-ranked setting. In particular, imagine a type like this:
• DeducedParamAttrs
  Parameter attributes that can only be determined by examining the body of a function instead of just its signature.
• DelegationFnSig
• Destructor
• DestructuredConst
  The constituent parts of a type level constant of kind ADT or array.
• EarlyBinderIter
• EarlyParamRegion
• EffectVid
  An effect variable ID.
• Expr
• Feed
  The same as TyCtxtFeed, but does not contain a TyCtxt. Use this to pass around when you have a TyCtxt elsewhere. Just an optimization to save space and not store hundreds of TyCtxtFeed in the resolver.
• FieldDef
• FloatVid
  A floating-point (f32 or f64) type variable ID.
• FnHeader
• FnSigTys
• FreeRegionInfo
  This struct contains information regarding a free parameter region, either a ReEarlyParam or ReLateParam.
• GenSig
• GenericArg
  An entity in the Rust type system, which can be one of several kinds (types, lifetimes, and consts). To reduce memory usage, a GenericArg is an interned pointer, with the lowest 2 bits being reserved for a tag to indicate the type (Ty, Region, or Const) it points to.
• GenericParamCount
• GenericParamDef
• GenericPredicates
  Bounds on generics.
• Generics
  Information about the formal type/lifetime parameters associated with an item or method. Analogous to hir::Generics.
• GlobalCtxt
  See TyCtxt for details about this type.
• ImplHeader
  The “header” of an impl is everything outside the body: a Self type, a trait ref (in the case of a trait impl), and a set of predicates (from the bounds / where-clauses).
• ImplTraitHeader
• InferVarInfo
• InlineConstArgs
  An inline const is modeled like
• InlineConstArgsParts
  Struct returned by split().
• Instance
  An InstanceKind along with the args that are needed to substitute the instance.
• InstantiatedPredicates
  Represents the bounds declared on a particular set of type parameters. Should eventually be generalized into a flag list of where-clauses. You can obtain an InstantiatedPredicates list from a GenericPredicates by using the instantiate method. Note that this method reflects an important semantic invariant of InstantiatedPredicates: while the GenericPredicates are expressed in terms of the bound type parameters of the impl/trait/whatever, an InstantiatedPredicates instance represented a set of bounds for some particular instantiation, meaning that the generic parameters have been instantiated with their values.
• IntVid
  An integral (u32, i32, usize, etc.) type variable ID.
• IntrinsicDef
• IsSuggestableVisitor
• IterInstantiated
• IterInstantiatedCopied
• LateParamRegion
  The parameter representation of late-bound function parameters, “some region at least as big as the scope fr.scope”.
• MainDefinition
• MakeSuggestableFolder
• OpaqueHiddenType
• ParamConst
• ParamEnv
  When interacting with the type system we must provide information about the environment. ParamEnv is the type that represents this information. See the dev guide chapter for more information.
• ParamEnvAnd
• ParamTag 🔒
• ParamTy
• Placeholder
  The “placeholder index” fully defines a placeholder region, type, or const. Placeholders are identified by both a universe, as well as a name residing within that universe. Distinct bound regions/types/consts within the same universe simply have an unknown relationship to one another.
• Predicate
  A statement that can be proven by a trait solver. This includes things that may show up in where clauses, such as trait predicates and projection predicates, and also things that are emitted as part of type checking such as DynCompatible predicate which is emitted when a type is coerced to a trait object.
• Region
  Use this rather than RegionKind, whenever possible.
• RegionVid
  A region variable ID.
• ReprFlags
• ReprOptions
  Represents the repr options provided by the user.
• ResolverAstLowering
  Resolutions that should only be used for lowering. This struct is meant to be consumed by lowering.
• ResolverGlobalCtxt
• ResolverOutputs
• RvalueScopes
  RvalueScopes is a mapping from sub-expressions to extended lifetime as determined by rules laid out in rustc_hir_analysis::check::rvalue_scopes.
• ScalarInt
  The raw bytes of a simple value.
• ShortInstance
• StaticLifetimeVisitor
  Collect al types that have an implicit 'static obligation that we could suggest '_ for.
• SymbolName
• Term
• TraitObjectVisitor
  Collect al types that have an implicit 'static obligation that we could suggest '_ for.
• Ty
  Use this rather than TyKind, whenever possible.
• TyCtxt
  The central data structure of the compiler. It stores references to the various arenas and also houses the results of the various compiler queries that have been performed. See the rustc dev guide for more details.
• TyCtxtFeed
  This struct should only be created by create_def.
• TyVid
  A type variable ID.
• TypeFlags
  Flags that we track on types. These flags are propagated upwards through the type during type construction, so that we can quickly check whether the type has various kinds of types in it without recursing over the type itself.
• TypeckResults
• UniverseIndex
  “Universes” are used during type- and trait-checking in the presence of for<..> binders to control what sets of names are visible. Universes are arranged into a tree: the root universe contains names that are always visible. Each child then adds a new set of names that are visible, in addition to those of its parent. We say that the child universe “extends” the parent universe with new names.
• UnusedGenericParams
• UpvarId
  Upvars do not get their own NodeId. Instead, we use the pair of the original var ID (that is, the root variable that is referenced by the upvar) and the ID of the closure expression.
• UpvarPath
• UserArgs
  Stores the user-given args to reach some fully qualified path (e.g., <T>::Item or <T as Trait>::Item).
• UserSelfTy
  Specifies the user-given self type. In the case of a path that refers to a member in an inherent impl, this self type is sometimes needed to constrain the type parameters on the impl. For example, in this code:
• UserTypeAnnotationIndex
• ValidateBoundVars
• VariantDef
  Definition of a variant – a struct’s fields or an enum variant.
• VariantFlags
• WithCachedTypeInfo
  A helper type that you can wrap round your own type in order to automatically cache the stable hash, type flags and debruijn index on creation and not recompute it whenever the information is needed. This is only done in incremental mode. You can also opt out of caching by using StableHash::ZERO for the hash, in which case the hash gets computed each time. This is useful if you have values that you intern but never (can?) use for stable hashing.

Enums

• AdtKind
• AliasRelationDirection
• AliasTermKind
• AliasTyKind
• AssocItemContainer
• AssocKind
• Asyncness
• BorrowKind
• BoundConstness
• BoundRegionKind
• BoundTyKind
• BoundVariableKind
• CanonicalTyVarKind
  Rust actually has more than one category of type variables; notably, the type variables we create for literals (e.g., 22 or 22.) can only be instantiated with integral/float types (e.g., usize or f32). In order to faithfully reproduce a type, we need to know what set of types a given type variable can be unified with.
• CanonicalVarKind
  Describes the “kind” of the canonical variable. This is a “kind” in the type-theory sense of the term – i.e., a “meta” type system that analyzes type-like values.
• ClosureKind
  Represents the various closure traits in the language. This will determine the type of the environment (self, in the desugaring) argument that the closure expects.
• DynKind
  Specifies how a trait object is represented.
• EffectKind
• ExprKind
• FeedConstTy
  In some cases, hir::ConstArgs that are being used in the type system through const generics need to have their type “fed” to them using the query system.
• FloatTy
• FloatVarValue
• GenericParamDefKind
• ImplOverlapKind
• ImplPolarity
• ImplSubject
• ImplTraitInTraitData
  Useful source information about where a desugared associated type for an RPITIT originated from.
• InferConst
  An inference variable for a const, for use in const generics.
• InferTy
  A placeholder for a type that hasn’t been inferred yet.
• InstanceKind
• IntTy
• IntVarValue
• Movability
  The movability of a coroutine / closure literal: whether a coroutine contains self-references, causing it to be !Unpin.
• Mutability
• ParamTerm
• PredicatePolarity
  Polarity for a trait predicate. May either be negative or positive. Distinguished from ImplPolarity since we never compute goals with “reservation” level.
• ReifyReason
  Describes why a ReifyShim was created. This is needed to distinguish a ReifyShim created to adjust for things like #[track_caller] in a vtable from a ReifyShim created to produce a function pointer from a vtable entry. Currently, this is only used when KCFI is enabled, as only KCFI needs to treat those two ReifyShims differently.
• Representability
• TermVid
• UintTy
• UpvarArgs
• UpvarCapture
  Information describing the capture of an upvar. This is computed during typeck, specifically by regionck.
• UserType
  A user-given type annotation attached to a constant. These arise from constants that are named via paths, like Foo::<A>::new and so forth.
• ValTree
  This datastructure is used to represent the value of constants used in the type system.
• Variance
• VarianceDiagInfo
  Extra information about why we ended up with a particular variance. This is only used to add more information to error messages, and has no effect on soundness. While choosing the ‘wrong’ VarianceDiagInfo may lead to confusing notes in error messages, it will never cause a miscompilation or unsoundness.
• VariantDiscr
• Visibility

Constants

• CAPTURE_STRUCT_LOCAL
  Captures are represented using fields inside a structure. This represents accessing self in the closure structure
• CONST_TAG 🔒
• INNERMOST
• SHORTHAND_OFFSET
  The shorthand encoding uses an enum’s variant index usize and is offset by this value so it never matches a real variant. This offset is also chosen so that the first byte is never < 0x80.
• TAG_MASK 🔒
• TYPE_TAG 🔒

Traits

• Article
• CollectAndApply
  Imagine you have a function F: FnOnce(&[T]) -> R, plus an iterator iter that produces T items. You could combine them with f(&iter.collect::<Vec<_>>()), but this requires allocating memory for the Vec.
• CoroutineArgsExt
• ExistentialPredicateStableCmpExt
• FallibleTypeFolder
  This trait is implemented for every folding traversal. There is a fold method defined for every type of interest. Each such method has a default that does an “identity” fold.
• InferCtxtLike
• Interner
• IsIdentity
• IsSuggestable
• Lift
  A trait implemented for all X<'a> types that can be safely and efficiently converted to X<'tcx> as long as they are part of the provided TyCtxt<'tcx>. This can be done, for example, for Ty<'tcx> or GenericArgsRef<'tcx> by looking them up in their respective interners.
• ParameterizedOverTcx
• RefDecodable
  Trait for decoding to a reference.
• TermKindPackExt
• ToPolyTraitRef
• TyDecoder
• TyEncoder
• TypeFoldable
  This trait is implemented for every type that can be folded, providing the skeleton of the traversal.
• TypeFolder
  This trait is implemented for every infallible folding traversal. There is a fold method defined for every type of interest. Each such method has a default that does an “identity” fold. Implementations of these methods often fall back to a super_fold_with method if the primary argument doesn’t satisfy a particular condition.
• TypeSuperFoldable
• TypeSuperVisitable
• TypeVisitable
  This trait is implemented for every type that can be visited, providing the skeleton of the traversal.
• TypeVisitableExt
• TypeVisitor
  This trait is implemented for every visiting traversal. There is a visit method defined for every type of interest. Each such method has a default that recurses into the type’s fields in a non-custom fashion.
• Upcast
  An Into-like trait that takes TyCtxt to perform interner-specific transformations.
• UpcastFrom
  A From-like trait that takes TyCtxt to perform interner-specific transformations.

Functions

• analyze_coroutine_closure_captures
• ast_int_ty
• ast_uint_ty
• debug_bound_var
• float_ty
• int_ty
• is_ancestor_or_same_capture
  Return true if the proj_possible_ancestor represents an ancestor path to proj_capture or proj_possible_ancestor is same as proj_capture, assuming they both start off of the same root variable.
• place_to_string_for_capture
• provide
• suggest_arbitrary_trait_bound
• suggest_constraining_type_param
  Suggest restricting a type param with a new bound.
• suggest_constraining_type_params
  Suggest restricting a type param with a new bound.
• uint_ty

Type Aliases

• AliasTerm
• AliasTy
• Binder
• CanonicalPolyFnSig
• CanonicalUserType
  Canonical user type annotation.
• CanonicalUserTypeAnnotations
  Mapping of type annotation indices to canonical user type annotations.
• ClauseKind
• Clauses
• CoercePredicate
• ConstKind
• EarlyBinder
• ExistentialPredicate
• ExistentialProjection
• ExistentialTraitRef
• FnSig
• GenericArgKind
• GenericArgs
  List of generic arguments that are gonna be used to replace generic parameters.
• GenericArgsRef
• List
  List<T> is a bit like &[T], but with some critical differences.
• ListWithCachedTypeInfo
  A List that additionally stores type information inline to speed up TypeVisitableExt operations.
• MinCaptureInformationMap
  Given the closure DefId this map provides a map of root variables to minimum set of CapturedPlaces that need to be tracked to support all captures of that closure.
• MinCaptureList
  Part of MinCaptureInformationMap; List of CapturePlaces.
• NormalizesTo
• OpaqueTypeKey
• OutlivesPredicate
• PlaceholderConst
• PlaceholderRegion
• PlaceholderType
• PolyCoercePredicate
• PolyExistentialPredicate
• PolyExistentialProjection
• PolyExistentialTraitRef
• PolyFnSig
• PolyProjectionPredicate
• PolyRegionOutlivesPredicate
• PolySubtypePredicate
• PolyTraitPredicate
• PolyTraitRef
• PolyTypeOutlivesPredicate
• PredicateKind
• ProjectionPredicate
• RegionKind
• RegionOutlivesPredicate
• RegisteredTools
• RootVariableMinCaptureList
  Part of MinCaptureInformationMap; Maps a root variable to the list of CapturedPlace. Used to track the minimum set of Places that need to be captured to support all Places captured by the closure starting at a given root variable.
• SubtypePredicate
• TermKind
• TraitPredicate
• TraitRef
• TyKind
• TypeAndMut
• TypeOutlivesPredicate
• UnevaluatedConst