Module rustc_trait_selection::traits
source · Expand description
Trait Resolution. See the rustc dev guide for more information on how this works.
Re-exports
pub use self::project::NormalizeExt;
pub use self::project::normalize_inherent_projection;
pub use self::project::normalize_projection_type;
pub use self::FulfillmentErrorCode::*;
pub use self::ImplSource::*;
pub use self::ObligationCauseCode::*;
pub use self::SelectionError::*;
Modules
- Support code for rustdoc and external tools. You really don’t want to be using this unless you need to.
- See Rustc Dev Guide chapters on trait-resolution and trait-specialization for more info on how this works.
- Checking that constant values used in types can be successfully evaluated.
- engine 🔒
- fulfill 🔒
- Miscellaneous type-system utilities that are too small to deserve their own modules.
- “Object safety” refers to the ability for a trait to be converted to an object. In general, traits may only be converted to an object if all of their methods meet certain criteria. In particular, they must:
- Code for projecting associated types out of trait references.
- Experimental types for the trait query interface. The methods defined in this module are all based on canonicalization, which makes a canonical query by replacing unbound inference variables and regions, so that results can be reused more broadly. The providers for the queries defined here can be found in
rustc_traits
. - select 🔒Candidate selection. See the rustc dev guide for more information on how this works.
- Logic and data structures related to impl specialization, explained in greater detail below.
- util 🔒
Structs
- The fulfillment context is used to drive trait resolution. It consists of a list of obligations that must be (eventually) satisfied. The job is to track which are satisfied, which yielded errors, and which are still pending. At any point, users can call
select_where_possible
, and the fulfillment context will try to do selection, retaining only those obligations that remain ambiguous. This may be helpful in pushing type inference along. Once all type inference constraints have been generated, the methodselect_all_or_error
can be used to report any remaining ambiguous cases as errors. - Identifies a particular impl in the source, along with a set of substitutions from the impl’s type/lifetime parameters. The
nested
vector corresponds to the nested obligations attached to the impl’s type parameters. - An
Obligation
represents some trait reference (e.g.,i32: Eq
) for which the “impl_source” must be found. The process of finding an “impl_source” is called “resolving” theObligation
. This process consists of either identifying animpl
(e.g.,impl Eq for i32
) that satisfies the obligation, or else finding a bound that is in scope. The eventual result is usually aSelection
(defined below). - The reason why we incurred this obligation; used for error reporting.
- Used if you want to have pleasant experience when dealing with obligations outside of hir or mir typeck.
- Information pertinent to an overlapping impl error.
- The projection cache. Unlike the standard caches, this can include infcx-dependent type variables, therefore we have to roll the cache back each time we roll a snapshot back, to avoid assumptions on yet-unresolved inference variables. Types with placeholder regions also have to be removed when the respective snapshot ends.
- “Trait alias expansion” is the process of expanding a sequence of trait references into another sequence by transitively following all trait aliases. e.g. If you have bounds like
Foo + Send
, a trait aliastrait Foo = Bar + Sync;
, and another trait aliastrait Bar = Read + Write
, then the bounds would expand toRead + Write + Sync + Send
. Expansion is done via a DFS (depth-first search), and thevisited
field is used to avoid cycles.
Enums
- These are the error cases for
codegen_select_candidate
. - The result of trait evaluation. The order is important here as the evaluation of a list is the maximum of the evaluations.
- Given the successful resolution of an obligation, the
ImplSource
indicates where the impl comes from. - Reasons a method might not be object-safe.
- Indicates that trait evaluation caused overflow and in which pass.
- Depending on the stage of compilation, we want projection to be more or less conservative.
- Whether to skip the leak check, as part of a future compatibility warning step.
- The mode that trait queries run in.
- The ‘location’ at which we try to perform HIR-based wf checking. This information is used to obtain an
hir::Ty
, which we can walk in order to obtain precise spans for any ‘nested’ types (e.g.Foo
inOption<Foo>
).
Traits
Functions
- Returns the object safety violations that affect astconv – currently,
Self
in supertraits. This is needed becauseobject_safety_violations
can’t be used during type collection. - Normalize a type and process all resulting obligations, returning any errors.
- Given an upcast trait object described by
object
, returns the index of the methodmethod_def_id
(which should be part ofobject.upcast_trait_ref
) within the vtable forobject
. - Normalizes the predicates and checks whether they hold in an empty environment. If this returns true, then either normalize encountered an error or one of the predicates did not hold. Used when creating vtables to check for unsatisfiable methods.
- Checks whether a trait’s associated item is impossible to reference on a given impl.
- We say a method is vtable safe if it can be invoked on a trait object. Note that object-safe traits can have some non-vtable-safe methods, so long as they require
Self: Sized
or otherwise ensure that they cannot be used whenSelf = Trait
. - Normalizes the parameter environment, reporting errors if they occur.
- Checks the coherence orphan rules.
impl_def_id
should be theDefId
of a trait impl. To pass, either the trait must be local, or else two conditions must be satisfied: - If there are types that satisfy both impls, returns
Some
with a suitably-freshenedImplHeader
with those types substituted. Otherwise, returnsNone
. - FIXME(@lcnr): this function doesn’t seem right and shouldn’t exist?
- Creates predicate obligations from the generic bounds.
- This method traverses the structure of
ty
, trying to find an instance of an ADT (i.e. struct or enum) that doesn’t implement the structural-match traits, or a generic type parameter (which cannot be determined to be structural-match). - A specialized variant of
elaborate
that only elaborates trait references that may define the given associated item with the nameassoc_name
. It uses thesuper_predicates_that_define_assoc_item
query to avoid enumerating super-predicates that aren’t related toassoc_item
. This is used when resolving types likeSelf::Item
orT::Item
and helps to avoid cycle errors (see e.g. #35237). - Given a subst for the requested impl, translate it to a subst appropriate for the actual item definition (whether it be in that impl, a parent impl, or the trait).
- Like translate_args, but obligations from the parent implementation are registered with the provided
ObligationCause
. - Determines whether the type
ty
is known to meetbound
and returns true if so. Returns false ifty
either does not meetbound
or is not known to meet bound (note that this is conservative towards no impl, which is the opposite of theevaluate
methods). - Casts a trait reference into a reference to one of its super traits; returns
None
iftarget_trait_def_id
is not a supertrait.
Type Aliases
- When performing resolution, it is typically the case that there can be one of three outcomes: