Module rustc_middle::ty
source · Expand description
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::visit::TypeVisitableExt;
pub use self::binding::BindingMode;
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 self::AssocItemContainer::*;
pub use self::BorrowKind::*;
pub use self::IntVarValue::*;
pub use self::Variance::*;
pub use self::AssocItemContainer::*;
pub use vtable::*;
pub use rustc_type_ir::AliasKind::*;
pub use rustc_type_ir::DynKind::*;
pub use rustc_type_ir::InferTy::*;
pub use rustc_type_ir::RegionKind::*;
pub use rustc_type_ir::TyKind::*;
pub use self::binding::BindingMode::*;
pub use self::sty::BoundRegionKind::*;
Modules
- A subset of a mir body used for const evaluability checking.
- adt 🔒
- assoc 🔒
- closure 🔒
- 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.
- Diagnostics related methods for
Ty
. - generics 🔒
- impls_ty 🔒This module contains
HashStable
implementations for various data types fromrustc_middle::ty
in no particular order. - 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 aParamEnv
and module ID. - instance 🔒
- list 🔒
- 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(...)
. - Generalized type relating mechanism.
- This module contains implementations of the
Lift
,TypeFoldable
andTypeVisitable
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. - Miscellaneous type-system utilities that are too small to deserve their own modules.
- An iterator over the type substructure. WARNING: this does not keep track of the region depth.
Structs
- The definition of a user-defined type, e.g., a
struct
,enum
, orunion
. - Represents the projection of an associated type.
- Information about an associated item
- A list of
ty::AssocItem
s in definition order that allows for efficient lookup by name. - Binder is a binder for higher-ranked lifetimes or types. It is part of the compiler’s representation for things like
for<'a> Fn(&'a isize)
(which would be represented by the typePolyTraitRef == Binder<'tcx, TraitRef>
). Note that when we instantiate, erase, or otherwise “discharge” these bound vars, we change the type fromBinder<'tcx, T>
to justT
(see e.g.,liberate_late_bound_regions
). - 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. - A composite describing a
Place
that is captured by a closure. - 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. - A closure can be modeled as a struct that looks like:
- Struct returned by
split()
. - Encodes that we have to coerce from the
a
type to theb
type. - Use this rather than
ConstData
, whenever possible. - Typed constant value.
- A type for representing any integer. Only used for printing.
- A
const
variable ID. - 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). - 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. - 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. - 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:
- Parameter attributes that can only be determined by examining the body of a function instead of just its signature.
- The constituent parts of a type level constant of kind ADT or array.
- Similar to
super::Binder
except that it tracks early bound generics, i.e.struct Foo<T>(T)
needsT
instantiated immediately. This type primarily exists to avoid forgetting to callinstantiate
. - An effect variable ID.
- A
ProjectionPredicate
for anExistentialTraitRef
. - An existential reference to a trait, where
Self
is erased. For example, the trait objectTrait<'a, 'b, X, Y>
is: - A floating-point (
f32
orf64
) type variable ID. - Signature of a function type, which we have arbitrarily decided to use to refer to the input/output types.
- A “free” region
fr
can be interpreted as “some region at least as big as the scopefr.scope
”. - This struct contains information regarding the
ReFree(FreeRegion)
corresponding to a lifetime conflict. - Similar to
ClosureArgs
; see the above documentation for more. - 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
, orConst
) it points to. - Bounds on generics.
- Information about the formal type/lifetime parameters associated with an item or method. Analogous to
hir::Generics
. - See TyCtxt for details about this type.
- 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).
- An inline const is modeled like
- Struct returned by
split()
. - A monomorphized
InstanceDef
. - 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 aGenericPredicates
by using theinstantiate
method. Note that this method reflects an important semantic invariant ofInstantiatedPredicates
: while theGenericPredicates
are expressed in terms of the bound type parameters of the impl/trait/whatever, anInstantiatedPredicates
instance represented a set of bounds for some particular instantiation, meaning that the generic parameters have been substituted with their values. - An integral (
u32
,i32
,usize
, etc.) type variable ID. List<T>
is a bit like&[T]
, but with some critical differences.A: B
- When type checking, we use the
ParamEnv
to track details about the set of where-clauses that are in scope at this particular point. - ParamTag 🔒
- 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.
- 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
ObjectSafe
predicate which is emitted when a type is coerced to a trait object. - This kind of predicate has no direct correspondent in the syntax, but it roughly corresponds to the syntactic forms:
- Use this rather than
RegionKind
, whenever possible. - A region (lifetime) variable ID.
- Represents the repr options provided by the user.
- Resolutions that should only be used for lowering. This struct is meant to be consumed by lowering.
RvalueScopes
is a mapping from sub-expressions to extended lifetime as determined by rules laid out inrustc_hir_analysis::check::rvalue_scopes
.- The raw bytes of a simple value.
- Collect al types that have an implicit
'static
obligation that we could suggest'_
for. - Encodes that
a
must be a subtype ofb
. Thea_is_expected
flag indicates whether thea
type is the type that we should label as “expected” when presenting user diagnostics. - Collect al types that have an implicit
'static
obligation that we could suggest'_
for. - A complete reference to a trait. These take numerous guises in syntax, but perhaps the most recognizable form is in a where-clause:
- Use this rather than
TyKind
, whenever possible. - 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.
- This struct should only be created by
create_def
. - A type variable ID.
- 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.
- An unevaluated (potentially generic) constant used in the type-system.
- “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. - 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. - Stores the user-given args to reach some fully qualified path (e.g.,
<T>::Item
or<T as Trait>::Item
). - 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:
- Definition of a variant – a struct’s fields or an enum variant.
- 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
- A clause is something that can appear in where bounds or be inferred by implied bounds.
- 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. - Specifies how a trait object is represented.
- Useful source information about where a desugared associated type for an RPITIT originated from.
- An inference variable for a const, for use in const generics.
- A placeholder for a type that hasn’t been inferred yet.
- Information describing the capture of an upvar. This is computed during
typeck
, specifically byregionck
. - 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. - This datastructure is used to represent the value of constants used in the type system.
- 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.
Constants
- Captures are represented using fields inside a structure. This represents accessing self in the closure structure
- 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
- Imagine you have a function
F: FnOnce(&[T]) -> R
, plus an iteratoriter
that producesT
items. You could combine them withf(&iter.collect::<Vec<_>>())
, but this requires allocating memory for theVec
. - 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.
- Needed so we can use #[derive(HashStable_Generic)]
- A trait implemented for all
X<'a>
types that can be safely and efficiently converted toX<'tcx>
as long as they are part of the providedTyCtxt<'tcx>
. This can be done, for example, forTy<'tcx>
orGenericArgsRef<'tcx>
by looking them up in their respective interners. - Trait for decoding to a reference.
- This trait is implemented for every type that can be folded, providing the skeleton of the traversal.
- 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. - This trait is implemented for every type that can be visited, providing the skeleton of the traversal.
- 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.
Functions
- Return true if the
proj_possible_ancestor
represents an ancestor path toproj_capture
orproj_possible_ancestor
is same asproj_capture
, assuming they both start off of the same root variable. - Yields the parent function’s
LocalDefId
ifdef_id
is animpl Trait
definition. - Suggest restricting a type param with a new bound.
- Suggest restricting a type param with a new bound.
Type Aliases
- Canonical user type annotation.
- Mapping of type annotation indices to canonical user type annotations.
- List of generic arguments that are gonna be used to replace generic parameters.
- Given the closure DefId this map provides a map of root variables to minimum set of
CapturedPlace
s that need to be tracked to support all captures of that closure. - Part of
MinCaptureInformationMap
; List ofCapturePlace
s. - Part of
MinCaptureInformationMap
; Maps a root variable to the list ofCapturedPlace
. Used to track the minimum set ofPlace
s that need to be captured to support all Places captured by the closure starting at a given root variable.