Module traits

Trait Resolution. See the rustc dev guide for more information on how this works.

Re-exports

• pub use self::normalize::NormalizeExt;
• pub use self::project::normalize_inherent_projection;
• pub use self::project::normalize_projection_ty;

Modules

• auto_trait
  Support code for rustdoc and external tools. You really don’t want to be using this unless you need to.
• coherence 🔒
  See Rustc Dev Guide chapters on trait-resolution and trait-specialization for more info on how this works.
• const_evaluatable
  Checking that constant values used in types can be successfully evaluated.
• dyn_compatibility 🔒
  “Dyn-compatibility” refers to the ability for a trait to be converted to a trait object. In general, traits may only be converted to a trait object if certain criteria are met.
• effects
• engine 🔒
• fulfill 🔒
• misc
  Miscellaneous type-system utilities that are too small to deserve their own modules.
• normalize
  Deeply normalize types using the old trait solver.
• outlives_bounds
• project
  Code for projecting associated types out of trait references.
• query
  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.
• solve
• specialization_graph
• specialize 🔒
  Logic and data structures related to impl specialization, explained in greater detail below.
• structural_normalize 🔒
• util 🔒
• vtable
• wf

Structs

• BoundVarReplacer
• DerivedCause
• FulfillmentContext
  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 method select_all_or_error can be used to report any remaining ambiguous cases as errors.
• FulfillmentError
• FutureCompatOverlapError
• IfExpressionCause
• ImplDerivedCause
• ImplSourceUserDefinedData
  Identifies a particular impl in the source, along with a set of generic parameters from the impl’s type/lifetime parameters. The nested vector corresponds to the nested obligations attached to the impl’s type parameters.
• InternedObligationCauseCode
• MatchExpressionArmCause
• MismatchedProjectionTypes
• Normalized
• Obligation
  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” the Obligation. This process consists of either identifying an impl (e.g., impl Eq for i32) that satisfies the obligation, or else finding a bound that is in scope. The eventual result is usually a Selection (defined below).
• ObligationCause
  The reason why we incurred this obligation; used for error reporting.
• ObligationCtxt
  Used if you want to have pleasant experience when dealing with obligations outside of hir or mir typeck.
• OldSolverError
• OverlapError
  Information pertinent to an overlapping impl error.
• OverlapResult
• PendingPredicateObligation
• PlaceholderReplacer
  The inverse of BoundVarReplacer: replaces placeholders with the bound vars from which they came.
• ProjectionCache
  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.
• ProjectionCacheKey
• ProjectionCacheStorage
• SelectionContext
• SignatureMismatchData
• TraitAliasExpander
  “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 alias trait Foo = Bar + Sync;, and another trait alias trait Bar = Read + Write, then the bounds would expand to Read + Write + Sync + Send. Expansion is done via a DFS (depth-first search), and the visited field is used to avoid cycles.
• TraitAliasExpansionInfo
  Stores information about the expansion of a trait via a path of zero or more trait aliases.
• UncoveredTyParams
• UnifyReceiverContext

Enums

• BuiltinImplSource
• CodegenObligationError
  These are the error cases for codegen_select_candidate.
• DynCompatibilityViolation
• DynCompatibilityViolationSolution
• EvaluationResult
  The result of trait evaluation. The order is important here as the evaluation of a list is the maximum of the evaluations.
• FulfillmentErrorCode
• FutureCompatOverlapErrorKind
• ImplSource
  Given the successful resolution of an obligation, the ImplSource indicates where the impl comes from.
• InCrate
  Whether we do the orphan check relative to this crate or to some remote crate.
• IntercrateAmbiguityCause
• IsConstable
  Whether a value can be extracted into a const. Used for diagnostics around array repeat expressions.
• IsFirstInputType
• MethodViolationCode
  Reasons a method might not be dyn-compatible.
• ObligationCauseCode
• OrphanCheckErr
• OrphanCheckMode
• OverflowError
  Indicates that trait evaluation caused overflow and in which pass.
• ProjectionCacheEntry
• Reveal
  Depending on the stage of compilation, we want projection to be more or less conservative.
• ScrubbedTraitError
  A trait error with most of its information removed. This is the error returned by an ObligationCtxt by default, and suitable if you just want to see if a predicate holds, and don’t particularly care about the error itself (except for if it’s an ambiguity or true error).
• SelectionError
• SkipLeakCheck
  Whether to skip the leak check, as part of a future compatibility warning step.
• StatementAsExpression
• TraitQueryMode
  The mode that trait queries run in.
• WellFormedLoc
  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 in Option<Foo>).

Traits

• FromSolverError
• StructurallyNormalizeExt
• TraitEngine
• TraitEngineExt

Functions

• add_placeholder_note
• do_normalize_predicates 🔒
• dyn_compatibility_violations_for_assoc_item
  Returns Some(_) if this item makes the containing trait dyn-incompatible.
• elaborate
• expand_trait_aliases
• hir_ty_lowering_dyn_compatibility_violations
  Returns the dyn-compatibility violations that affect HIR ty lowering.
• impl_item_is_final
• impossible_predicates
  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. This should not be used during analysis.
• instantiate_and_check_impossible_predicates 🔒
• is_impossible_associated_item 🔒
  Checks whether a trait’s associated item is impossible to reference on a given impl.
• is_vtable_safe_method
  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 when Self = Trait.
• normalize_param_env_or_error
  Normalizes the parameter environment, reporting errors if they occur.
• orphan_check_trait_ref
  Checks whether a trait-ref is potentially implementable by a crate.
• overlapping_impls
  If there are types that satisfy both impls, returns Some with a suitably-freshened ImplHeader with those types instantiated. Otherwise, returns None.
• pred_known_to_hold_modulo_regions 🔒
  FIXME(@lcnr): this function doesn’t seem right and shouldn’t exist?
• predicates_for_generics
  Creates predicate obligations from the generic bounds.
• provide
• supertraits
• transitive_bounds_that_define_assoc_item
  A specialized variant of elaborate that only elaborates trait references that may define the given associated item with the name assoc_name. It uses the explicit_supertraits_containing_assoc_item query to avoid enumerating super-predicates that aren’t related to assoc_item. This is used when resolving types like Self::Item or T::Item and helps to avoid cycle errors (see e.g. #35237).
• translate_args
  Given the generic parameters for the requested impl, translate it to the generic parameters appropriate for the actual item definition (whether it be in that impl, a parent impl, or the trait).
• translate_args_with_cause
  Like translate_args, but obligations from the parent implementation are registered with the provided ObligationCause.
• type_known_to_meet_bound_modulo_regions
  Determines whether the type ty is known to meet bound and returns true if so. Returns false if ty either does not meet bound or is not known to meet bound (note that this is conservative towards no impl, which is the opposite of the evaluate methods).
• upcast_choices
  Casts a trait reference into a reference to one of its super traits; returns None if target_trait_def_id is not a supertrait.
• with_replaced_escaping_bound_vars
  Executes f on value after replacing all escaping bound variables with placeholders and then replaces these placeholders with the original bound variables in the result.

Type Aliases

• EvaluationCache
• NormalizedTerm
• ObligationInspector
  A callback that can be provided to inspect_typeck. Invoked on evaluation of root obligations.
• PolyTraitObligation
• PredicateObligation
• PredicateObligations
• Selection
• SelectionCache
• SelectionResult
  When performing resolution, it is typically the case that there can be one of three outcomes:
• TraitObligation