Struct InferenceResult 

pub struct InferenceResult<'db> {

    method_resolutions: HashMap<Idx<Expr>, (FunctionId, StoredGenericArgs), FxBuildHasher>,
    field_resolutions: HashMap<Idx<Expr>, Either<FieldId, TupleFieldId>, FxBuildHasher>,
    variant_resolutions: HashMap<ExprOrPatIdPacked, VariantId, FxBuildHasher>,
    assoc_resolutions: HashMap<ExprOrPatIdPacked, (CandidateId, StoredGenericArgs), FxBuildHasher>,
    tuple_field_access_types: ThinVec<StoredTys>,
    pub type_of_expr: ArenaMap<Idx<Expr>, StoredTy>,
    pub type_of_pat: ArenaMap<Idx<Pat>, StoredTy>,
    pub type_of_binding: ArenaMap<Idx<Binding>, StoredTy>,
    pub type_of_type_placeholder: HashMap<Idx<TypeRef>, StoredTy, FxBuildHasher>,
    pub type_of_opaque: HashMap<InternedOpaqueTyId<'db>, StoredTy, FxBuildHasher>,
    pub has_errors: bool,
    diagnostics: ThinVec<InferenceDiagnostic>,
    nodes_with_type_mismatches: Option<Box<HashSet<ExprOrPatIdPacked, FxBuildHasher>>>,
    error_ty: StoredTy,
    pub expr_adjustments: HashMap<Idx<Expr>, Box<[Adjustment]>, FxBuildHasher>,
    pub pat_adjustments: HashMap<Idx<Pat>, Vec<PatAdjustment>, FxBuildHasher>,
    pub binding_modes: ArenaMap<Idx<Pat>, BindingMode>,
    skipped_ref_pats: HashSet<Idx<Pat>, FxBuildHasher>,
    pub coercion_casts: HashSet<Idx<Expr>, FxBuildHasher>,
    pub closures_data: HashMap<Idx<Expr>, ClosureData, FxBuildHasher>,
    defined_anon_consts: ThinVec<AnonConstId<'db>>,
}

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

method_resolutions: HashMap<Idx<Expr>, (FunctionId, StoredGenericArgs), FxBuildHasher>

field_resolutions: HashMap<Idx<Expr>, Either<FieldId, TupleFieldId>, FxBuildHasher>

variant_resolutions: HashMap<ExprOrPatIdPacked, VariantId, FxBuildHasher>

assoc_resolutions: HashMap<ExprOrPatIdPacked, (CandidateId, StoredGenericArgs), FxBuildHasher>

tuple_field_access_types: ThinVec<StoredTys>

type_of_expr: ArenaMap<Idx<Expr>, StoredTy>

type_of_pat: ArenaMap<Idx<Pat>, StoredTy>

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<Idx<Binding>, StoredTy>

type_of_type_placeholder: HashMap<Idx<TypeRef>, StoredTy, FxBuildHasher>

type_of_opaque: HashMap<InternedOpaqueTyId<'db>, StoredTy, FxBuildHasher>

has_errors: bool

Whether there are any type-mismatching errors in the result.

diagnostics: ThinVec<InferenceDiagnostic>

nodes_with_type_mismatches: Option<Box<HashSet<ExprOrPatIdPacked, FxBuildHasher>>>

error_ty: StoredTy

expr_adjustments: HashMap<Idx<Expr>, Box<[Adjustment]>, FxBuildHasher>

pat_adjustments: HashMap<Idx<Pat>, Vec<PatAdjustment>, FxBuildHasher>

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

binding_modes: ArenaMap<Idx<Pat>, 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,
    };
    0
}

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

skipped_ref_pats: HashSet<Idx<Pat>, FxBuildHasher>

coercion_casts: HashSet<Idx<Expr>, FxBuildHasher>

closures_data: HashMap<Idx<Expr>, ClosureData, FxBuildHasher>

defined_anon_consts: ThinVec<AnonConstId<'db>>

Implementations

impl<'db> InferenceResult<'db>

pub fn of( db: &'db (dyn HirDatabase + 'static), def: impl Into<InferBodyId<'db>>, ) -> &'db InferenceResult<'db>

impl<'db> InferenceResult<'db>

pub fn method_resolution( &self, expr: Idx<Expr>, ) -> Option<(FunctionId, GenericArgs<'db>)>

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

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

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

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

pub fn assoc_resolutions_for_expr<'a>( &self, id: Idx<Expr>, ) -> Option<(CandidateId, GenericArgs<'a>)>

pub fn assoc_resolutions_for_pat<'a>( &self, id: Idx<Pat>, ) -> Option<(CandidateId, GenericArgs<'a>)>

pub fn assoc_resolutions_for_expr_or_pat<'a>( &self, id: ExprOrPatId, ) -> Option<(CandidateId, GenericArgs<'a>)>

pub fn expr_or_pat_has_type_mismatch(&self, node: ExprOrPatIdPacked) -> bool

pub fn expr_has_type_mismatch(&self, expr: Idx<Expr>) -> bool

pub fn pat_has_type_mismatch(&self, pat: Idx<Pat>) -> bool

pub fn exprs_have_type_mismatches(&self) -> bool

pub fn has_type_mismatches(&self) -> bool

pub fn placeholder_types<'a>( &self, ) -> impl Iterator<Item = (Idx<TypeRef>, Ty<'a>)>

pub fn type_of_type_placeholder<'a>( &self, type_ref: Idx<TypeRef>, ) -> Option<Ty<'a>>

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

pub fn type_of_expr_with_adjust<'a>(&self, id: Idx<Expr>) -> Option<Ty<'a>>

pub fn type_of_pat_with_adjust<'a>(&self, id: Idx<Pat>) -> Ty<'a>

pub fn is_erroneous(&self) -> bool

pub fn diagnostics(&self) -> &[InferenceDiagnostic]

pub fn tuple_field_access_type<'a>(&self, id: TupleId) -> Tys<'a>

pub fn pat_adjustment(&self, id: Idx<Pat>) -> Option<&[PatAdjustment]>

pub fn expr_adjustment(&self, id: Idx<Expr>) -> Option<&[Adjustment]>

pub fn binding_mode(&self, id: Idx<Pat>) -> Option<BindingMode>

pub fn expression_types<'a>(&self) -> impl Iterator<Item = (Idx<Expr>, Ty<'a>)>

pub fn pattern_types<'a>(&self) -> impl Iterator<Item = (Idx<Pat>, Ty<'a>)>

pub fn binding_types<'a>(&self) -> impl Iterator<Item = (Idx<Binding>, Ty<'a>)>

pub fn return_position_impl_trait_types<'a>( &'a self, db: &'a (dyn HirDatabase + 'static), ) -> impl Iterator<Item = (Idx<ImplTrait>, Ty<'a>)>

pub fn expr_ty<'a>(&self, id: Idx<Expr>) -> Ty<'a>

pub fn pat_ty<'a>(&self, id: Idx<Pat>) -> Ty<'a>

pub fn expr_or_pat_ty<'a>(&self, id: ExprOrPatId) -> Ty<'a>

pub fn binding_ty<'a>(&self, id: Idx<Binding>) -> Ty<'a>

pub fn closure_captures_tys<'a>( &self, closure: Idx<Expr>, ) -> impl Iterator<Item = Ty<'a>>

This does not deduplicate, which means you’ll get the types once per capture.

pub fn closure_captures_captured_tys<'a>( &self, db: &'a (dyn HirDatabase + 'static), closure: Idx<Expr>, ) -> impl Iterator<Item = Ty<'a>>

Like Self::closure_captures_tys(), but using CapturedPlace::captured_ty().

pub fn is_skipped_ref_pat(&self, pat: Idx<Pat>) -> bool

Trait Implementations

impl<'db> Clone for InferenceResult<'db>

fn clone(&self) -> InferenceResult<'db>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'db> Debug for InferenceResult<'db>

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

Formats the value using the given formatter.

impl<'db> Eq for InferenceResult<'db>

impl<'db> PartialEq for InferenceResult<'db>

fn eq(&self, other: &InferenceResult<'db>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'db> SalsaValue for InferenceResult<'db>

impl<'db> StructuralPartialEq for InferenceResult<'db>