Struct InferenceResult

pub struct InferenceResult {
    pub tuple_field_access_types: FxHashMap<TupleId, Substitution>,
    pub diagnostics: Vec<InferenceDiagnostic>,
    pub type_of_expr: ArenaMap<ExprId, Ty>,
    pub type_of_pat: ArenaMap<PatId, Ty>,
    pub type_of_binding: ArenaMap<BindingId, Ty>,
    pub type_of_rpit: ArenaMap<ImplTraitIdx, Ty>,
    pub type_of_for_iterator: FxHashMap<ExprId, Ty>,
    pub pat_adjustments: FxHashMap<PatId, Vec<Ty>>,
    pub binding_modes: ArenaMap<PatId, BindingMode>,
    pub expr_adjustments: FxHashMap<ExprId, Vec<Adjustment>>,
    pub mutated_bindings_in_closure: FxHashSet<BindingId>,
    pub coercion_casts: FxHashSet<ExprId>,
    /* private fields */
}

The result of type inference: A mapping from expressions and patterns to types.

When you add a field that stores types (including Substitution and the like), don’t forget resolve_completely()’ing them in InferenceContext::resolve_all(). Inference variables must not appear in the final inference result.

Fields

tuple_field_access_types: FxHashMap<TupleId, Substitution>

Whenever a tuple field expression access a tuple field, we allocate a tuple id in [InferenceContext] and store the tuples substitution there. This map is the reverse of that which allows us to resolve a [TupleFieldId]s type.

diagnostics: Vec<InferenceDiagnostic>

type_of_expr: ArenaMap<ExprId, Ty>

type_of_pat: ArenaMap<PatId, Ty>

For each pattern record the type it resolves to.

Note: When a pattern type is resolved it may still contain unresolved or missing subpatterns or subpatterns of mismatched types.

type_of_binding: ArenaMap<BindingId, Ty>

type_of_rpit: ArenaMap<ImplTraitIdx, Ty>

type_of_for_iterator: FxHashMap<ExprId, Ty>

Type of the result of .into_iter() on the for. ExprId is the one of the whole for loop.

pat_adjustments: FxHashMap<PatId, Vec<Ty>>

Stores the types which were implicitly dereferenced in pattern binding modes.

binding_modes: ArenaMap<PatId, BindingMode>

Stores the binding mode (ref in let ref x = 2) of bindings.

This one is tied to the PatId instead of BindingId, because in some rare cases, a binding in an or pattern can have multiple binding modes. For example:

fn foo(mut slice: &[u32]) -> usize {
   slice = match slice {
       [0, rest @ ..] | rest => rest,
   };
}

the first rest has implicit ref binding mode, but the second rest binding mode is move.

expr_adjustments: FxHashMap<ExprId, Vec<Adjustment>>

mutated_bindings_in_closure: FxHashSet<BindingId>

coercion_casts: FxHashSet<ExprId>

Implementations

impl InferenceResult

pub fn method_resolution( &self, expr: ExprId, ) -> Option<(FunctionId, Substitution)>

pub fn field_resolution( &self, expr: ExprId, ) -> Option<Either<FieldId, TupleFieldId>>

pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantId>

pub fn variant_resolution_for_pat(&self, id: PatId) -> Option<VariantId>

pub fn variant_resolution_for_expr_or_pat( &self, id: ExprOrPatId, ) -> Option<VariantId>

pub fn assoc_resolutions_for_expr( &self, id: ExprId, ) -> Option<(AssocItemId, Substitution)>

pub fn assoc_resolutions_for_pat( &self, id: PatId, ) -> Option<(AssocItemId, Substitution)>

pub fn assoc_resolutions_for_expr_or_pat( &self, id: ExprOrPatId, ) -> Option<(AssocItemId, Substitution)>

pub fn type_mismatch_for_expr(&self, expr: ExprId) -> Option<&TypeMismatch>

pub fn type_mismatch_for_pat(&self, pat: PatId) -> Option<&TypeMismatch>

pub fn type_mismatches( &self, ) -> impl Iterator<Item = (ExprOrPatId, &TypeMismatch)>

pub fn expr_type_mismatches( &self, ) -> impl Iterator<Item = (ExprId, &TypeMismatch)>

pub fn closure_info(&self, closure: &ClosureId) -> &(Vec<CapturedItem>, FnTrait)

pub fn type_of_expr_or_pat(&self, id: ExprOrPatId) -> Option<&Ty>

Trait Implementations

impl Clone for InferenceResult

fn clone(&self) -> InferenceResult

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InferenceResult

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

Formats the value using the given formatter.

impl Default for InferenceResult

fn default() -> InferenceResult

Returns the “default value” for a type.

impl Index<ExprOrPatId> for InferenceResult

type Output = Ty<Interner>

The returned type after indexing.

fn index(&self, id: ExprOrPatId) -> &Ty

Performs the indexing (container[index]) operation.

impl Index<Idx<Binding>> for InferenceResult

type Output = Ty<Interner>

The returned type after indexing.

fn index(&self, b: BindingId) -> &Ty

Performs the indexing (container[index]) operation.

impl Index<Idx<Expr>> for InferenceResult

type Output = Ty<Interner>

The returned type after indexing.

fn index(&self, expr: ExprId) -> &Ty

Performs the indexing (container[index]) operation.

impl Index<Idx<Pat>> for InferenceResult

type Output = Ty<Interner>

The returned type after indexing.

fn index(&self, pat: PatId) -> &Ty

Performs the indexing (container[index]) operation.

impl PartialEq for InferenceResult

fn eq(&self, other: &InferenceResult) -> 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 Eq for InferenceResult

impl StructuralPartialEq for InferenceResult