mod place_op;

pub(crate) mod unify;

use base_db::Crate;

use either::Either;

use indexmap::IndexSet;

use intern::sym;

use la_arena::ArenaMap;

use rustc_ast_ir::Mutability;

use rustc_hash::{FxHashMap, FxHashSet};

use rustc_type_ir::{

AliasTyKind, TypeFoldable,

};

use span::Edition;

use stdx::never;

use thin_vec::ThinVec;

method_resolution::{CandidateId, MethodResolutionUnstableFeatures},

mir::MirSpan,

next_solver::{

abi::Safety,

infer::{InferCtxt, traits::ObligationCause},

},

pub(crate) use closure::analysis::{CaptureKind, CapturedItem, CapturedItemWithoutTy};

/// The entry point of type inference.

let _p = tracing::info_span!("infer_query").entered();

let resolver = def.resolver(db);

let body = db.body(def);

ctx.resolve_all()

}

InferenceResult {

has_errors: true,

..InferenceResult::new(Ty::new_error(DbInterner::new_no_crate(db), ErrorGuaranteed))

Signature,

}

NoSuchField {

field: ExprOrPatId,

private: Option<LocalFieldId>,

},

UnresolvedField {

expr: ExprId,

name: Name,

method_with_same_name_exists: bool,

},

UnresolvedMethodCall {

expr: ExprId,

name: Name,

/// Contains the type the field resolves to

assoc_func_with_same_name: Option<FunctionId>,

},

UnresolvedAssocItem {

},

ExpectedFunction {

call_expr: ExprId,

},

TypedHole {

expr: ExprId,

},

CastToUnsized {

expr: ExprId,

},

InvalidCast {

expr: ExprId,

error: CastError,

},

TyDiagnostic {

source: InferenceTyDiagnosticSource,

}

/// A mismatch between an expected and an inferred type.

}

/// Represents coercing a value to a different type of value.

/// At some point, of course, `Box` should move out of the compiler, in which

/// case this is analogous to transforming a struct. E.g., Box<[i32; 4]> ->

/// Box<[i32]> is an `Adjust::Unsize` with the target `Box<[i32]>`.

pub kind: Adjust,

}

let ty = Ty::new_ref(interner, lt, ty, m);

Adjustment {

kind: Adjust::Borrow(AutoBorrow::Ref(AutoBorrowMutability::new(m, AllowTwoPhase::No))),

}

}

}

/// 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.

/// For each method call expr, records the function it resolves to.

/// For each field access expr, records the field it resolves to.

field_resolutions: FxHashMap<ExprId, Either<FieldId, TupleFieldId>>,

/// For each struct literal or pattern, records the variant it resolves to.

variant_resolutions: FxHashMap<ExprOrPatId, VariantId>,

/// For each associated item record what it resolves to

/// 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.

/// 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.

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

// FIXME: This isn't as useful as initially thought due to us falling back placeholders to

// `TyKind::Error`.

// Which will then mark this field.

pub(crate) has_errors: bool,

/// During inference this field is empty and [`InferenceContext::diagnostics`] is filled instead.

/// Interned `Error` type to return references to.

// FIXME: Remove this.

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

/// 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

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

pub(crate) binding_modes: ArenaMap<PatId, BindingMode>,

// FIXME: remove this field

pub mutated_bindings_in_closure: FxHashSet<BindingId>,

}

#[salsa::tracked]

infer_query(db, def)

}

}

Self {

method_resolutions: Default::default(),

field_resolutions: Default::default(),

type_of_opaque: Default::default(),

type_mismatches: Default::default(),

has_errors: Default::default(),

pat_adjustments: Default::default(),

binding_modes: Default::default(),

expr_adjustments: Default::default(),

}

}

}

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

self.field_resolutions.get(&expr).copied()

ExprOrPatId::PatId(id) => self.variant_resolution_for_pat(id),

}

}

&self,

id: ExprId,

) -> Option<(CandidateId, GenericArgs<'db>)> {

}

}

&self,

id: ExprOrPatId,

) -> Option<(CandidateId, GenericArgs<'db>)> {

ExprOrPatId::PatId(id) => self.assoc_resolutions_for_pat(id),

}

}

self.type_mismatches.as_deref()?.get(&expr.into())

}

self.type_mismatches.as_deref()?.get(&pat.into())

}

self.type_mismatches

.as_deref()

.into_iter()

.flatten()

.map(|(expr_or_pat, mismatch)| (*expr_or_pat, mismatch))

}

self.type_mismatches.as_deref().into_iter().flatten().filter_map(

|(expr_or_pat, mismatch)| match *expr_or_pat {

ExprOrPatId::ExprId(expr) => Some((expr, mismatch)),

},

)

}

}

}

self.closure_info.get(&closure).unwrap()

}

match id {

}

}

match self.expr_adjustments.get(&id).and_then(|adjustments| {

adjustments.iter().rfind(|adj| {

// https://github.com/rust-lang/rust/blob/67819923ac8ea353aaa775303f4c3aacbf41d010/compiler/rustc_mir_build/src/thir/cx/expr.rs#L140

Adjustment {

kind: Adjust::NeverToAny,

target,

)

})

}) {

}

}

match self.pat_adjustments.get(&id).and_then(|adjustments| adjustments.last()) {

}

}

pub fn is_erroneous(&self) -> bool {

self.has_errors && self.type_of_expr.iter().count() == 0

}

&self.diagnostics

}

}

self.pat_adjustments.get(&id).map(|it| &**it)

}

self.expr_adjustments.get(&id).map(|it| &**it)

}

}

// This method is consumed by external tools to run rust-analyzer as a library. Don't remove, please.

}

// This method is consumed by external tools to run rust-analyzer as a library. Don't remove, please.

}

// This method is consumed by external tools to run rust-analyzer as a library. Don't remove, please.

}

// This method is consumed by external tools to run rust-analyzer as a library. Don't remove, please.

db: &'db dyn HirDatabase,

let ImplTraitId::ReturnTypeImplTrait(_, rpit_idx) = id.loc(db) else {

return None;

};

})

}

}

}

}

}

}

re_error: Region::error(interner),

re_erased: Region::new_erased(interner),

}

}

}

pub(crate) lang_items: &'db LangItems,

/// The traits in scope, disregarding block modules. This is used for caching purposes.

traits_in_scope: FxHashSet<TraitId>,

tuple_field_accesses_rev:

IndexSet<Tys<'db>, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>,

/// The return type of the function being inferred, the closure or async block if we're

deferred_cast_checks: Vec<CastCheck<'db>>,

// fields related to closure capture

/// A stack that has an entry for each projection in the current capture.

///

/// For example, in `a.b.c`, we capture the spans of `a`, `a.b`, and `a.b.c`.

closure_dependencies: FxHashMap<InternedClosureId, Vec<InternedClosureId>>,

deferred_closures: FxHashMap<InternedClosureId, Vec<(Ty<'db>, Ty<'db>, Vec<Ty<'db>>, ExprId)>>,

}

#[derive(Clone, Debug)]

/// Clones `self` and calls `resolve_all()` on it.

// FIXME: Remove this.

let mut ctx = self.clone();

ctx.type_inference_fallback();

// `InferenceResult` in the middle of inference. See the fixme comment in `consteval::eval_to_const`. If you

// used this function for another workaround, mention it here. If you really need this function and believe that

// there is no problem in it being `pub(crate)`, remove this comment.

let InferenceContext {

mut table, mut result, tuple_field_accesses_rev, diagnostics, ..

} = self;

} = &mut result;

for ty in type_of_expr.values_mut() {

}

type_of_expr.shrink_to_fit();

for ty in type_of_pat.values_mut() {

}

type_of_pat.shrink_to_fit();

for ty in type_of_binding.values_mut() {

}

type_of_binding.shrink_to_fit();

for ty in type_of_type_placeholder.values_mut() {

}

type_of_type_placeholder.shrink_to_fit();

type_of_opaque.shrink_to_fit();

if let Some(type_mismatches) = type_mismatches {

*has_errors = true;

for mismatch in type_mismatches.values_mut() {

}

type_mismatches.shrink_to_fit();

}

ExpectedFunction { found: ty, .. }

| UnresolvedField { receiver: ty, .. }

| UnresolvedMethodCall { receiver: ty, .. } => {

// FIXME: Remove this when we are on par with rustc in terms of inference

return false;

}

if let UnresolvedMethodCall { field_with_same_name, .. } = diagnostic

&& let Some(ty) = field_with_same_name

{

*field_with_same_name = None;

}

}

}

TypedHole { expected: ty, .. } => {

}

_ => (),

}

});

diagnostics.shrink_to_fit();

for (_, subst) in method_resolutions.values_mut() {

}

method_resolutions.shrink_to_fit();

for (_, subst) in assoc_resolutions.values_mut() {

}

assoc_resolutions.shrink_to_fit();

for adjustment in expr_adjustments.values_mut().flatten() {

}

expr_adjustments.shrink_to_fit();

for adjustment in pat_adjustments.values_mut().flatten() {

}

pat_adjustments.shrink_to_fit();

result.tuple_field_access_types = tuple_field_accesses_rev

.into_iter()

.inspect(|subst| {

})

.collect();

result.tuple_field_access_types.shrink_to_fit();

}

fn write_expr_ty(&mut self, expr: ExprId, ty: Ty<'db>) {

}

if adjustments.is_empty() {

return;

}

) => {

// NeverToAny coercion can target any type, so instead of adding a new

// adjustment on top we can change the target.

}

_ => {

*entry.get_mut() = adjustments;

}

}

if adjustments.is_empty() {

return;

}

func: FunctionId,

subst: GenericArgs<'db>,

) {

}

fn write_variant_resolution(&mut self, id: ExprOrPatId, variant: VariantId) {

item: CandidateId,

subs: GenericArgs<'db>,

) {

}

fn write_pat_ty(&mut self, pat: PatId, ty: Ty<'db>) {

}

fn write_type_placeholder_ty(&mut self, type_ref: TypeRefId, ty: Ty<'db>) {

}

fn write_binding_ty(&mut self, id: BindingId, ty: Ty<'db>) {

}

self.diagnostics.push(diagnostic);

}

match ty.kind() {

TyKind::Adt(adt_def, substs) => match adt_def.def_id().0 {

AdtId::StructId(struct_id) => {

Some(field) => {

ty = field.instantiate(self.interner(), substs);

}

self.result

.type_mismatches

.get_or_insert_default()

}

result

}

}

fn expr_ty(&self, expr: ExprId) -> Ty<'db> {

}

fn expr_ty_after_adjustments(&self, e: ExprId) -> Ty<'db> {

if let Some(it) = self.result.expr_adjustments.get(&e)

&& let Some(it) = it.last()

{

}

ty.unwrap_or_else(|| self.expr_ty(e))

}