AliasTyKind, TypeFoldable, TypeVisitableExt,

inherent::{GenericArgs as _, IntoKind, Ty as _},

};

use smallvec::SmallVec;

use span::Edition;

use stdx::never;

use cast::{CastCheck, CastError};

/// The entry point of type inference.

infer_query_with_inspect(db, def, None, LoweringMode::Analysis)

}

def: DefWithBodyId,

inspect: Option<ObligationInspector<'db>>,

lowering_mode: LoweringMode,

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

let resolver = def.resolver(db);

let body = Body::of(db, def);

infer_finalize(ctx)

}

InferenceResult {

has_errors: true,

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

}

/// Infer types for an anonymous const expression.

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

let loc = def.loc(db);

let store_owner = loc.owner;

infer_finalize(ctx)

}

_: salsa::Id,

InferenceResult {

has_errors: true,

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

}

}

ctx.handle_opaque_type_uses();

ctx.type_inference_fallback();

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

method_resolutions: FxHashMap<ExprId, (FunctionId, StoredGenericArgs)>,

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

pub closures_data: FxHashMap<ExprId, ClosureData>,

}

#[derive(Clone, PartialEq, Eq, Debug, Default)]

}

#[salsa::tracked]

#[salsa::tracked(returns(ref), cycle_result = infer_cycle_result)]

infer_query(db, def)

}

/// Infer types for all const expressions in an item's signature.

///

/// Returns an `InferenceResult` containing type information for array lengths,

/// const generic arguments, and other const expressions appearing in type

/// positions within the item's signature.

#[salsa::tracked(returns(ref), cycle_result = infer_anon_const_cycle_result)]

infer_anon_const_query(db, def)

}

#[inline]

match def.into() {

InferBodyId::DefWithBodyId(it) => InferenceResult::for_body(db, it),

InferBodyId::AnonConstId(it) => InferenceResult::for_anon_const(db, it),

}

}

fn new(error_ty: Ty<'_>) -> Self {

Self {

method_resolutions: Default::default(),

}

}

self.method_resolutions.get(&expr).map(|(func, args)| (*func, args.as_ref()))

}

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

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

}

}

&self,

id: ExprId,

self.assoc_resolutions.get(&id.into()).map(|(assoc, args)| (*assoc, args.as_ref()))

}

&self,

id: PatId,

self.assoc_resolutions.get(&id.into()).map(|(assoc, args)| (*assoc, args.as_ref()))

}

&self,

id: ExprOrPatId,

match id {

ExprOrPatId::ExprId(id) => self.assoc_resolutions_for_expr(id),

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

pub fn has_type_mismatches(&self) -> bool {

self.nodes_with_type_mismatches.is_some()

}

self.type_of_type_placeholder.iter().map(|(&type_ref, ty)| (type_ref, ty.as_ref()))

}

self.type_of_type_placeholder.get(&type_ref).map(|ty| ty.as_ref())

}

match id {

ExprOrPatId::ExprId(id) => self.type_of_expr.get(id).map(|it| it.as_ref()),

ExprOrPatId::PatId(id) => self.type_of_pat.get(id).map(|it| it.as_ref()),

}

}

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

None => self.type_of_expr.get(id).map(|it| it.as_ref()),

}

}

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

Some(adjusted) => adjusted.source.as_ref(),

None => self.pat_ty(id),

&self.diagnostics

}

self.tuple_field_access_types[id.0 as usize].as_ref()

}

}

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

self.type_of_expr.iter().map(|(k, v)| (k, v.as_ref()))

}

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

self.type_of_pat.iter().map(|(k, v)| (k, v.as_ref()))

}

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

self.type_of_binding.iter().map(|(k, v)| (k, v.as_ref()))

}

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

self.type_of_opaque.iter().filter_map(move |(&id, ty)| {

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

return None;

})

}

self.type_of_expr.get(id).map_or(self.error_ty.as_ref(), |it| it.as_ref())

}

self.type_of_pat.get(id).map_or(self.error_ty.as_ref(), |it| it.as_ref())

}

self.type_of_expr_or_pat(id).unwrap_or(self.error_ty.as_ref())

}

self.type_of_binding.get(id).map_or(self.error_ty.as_ref(), |it| it.as_ref())

}

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

self.closures_data[&closure]

.min_captures

.values()

}

/// Like [`Self::closure_captures_tys()`], but using [`CapturedPlace::captured_ty()`].

&self,

closure: ExprId,

self.closures_data[&closure]

.min_captures

.values()

/// The inference context contains all information needed during type inference.

#[derive(Debug)]

pub(crate) db: &'db dyn HirDatabase,

pub(crate) store_owner: ExpressionStoreOwnerId,

pub(crate) generic_def: GenericDefId,

pub(crate) lowering_mode: LoweringMode,

/// Generally you should not resolve things via this resolver. Instead create a TyLoweringContext

/// and resolve the path via its methods. This will ensure proper error reporting.

pub(crate) features: &'db UnstableFeatures,

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

diagnostics: Diagnostics,

vars_emitted_type_must_be_known_for: FxHashSet<Term<'db>>,

}

#[derive(Clone, Debug)]

}

}

fn new(

db: &'db dyn HirDatabase,

store_owner: ExpressionStoreOwnerId,

generic_def: GenericDefId,

resolver: Resolver<'db>,

allow_using_generic_params: bool,

lowering_mode: LoweringMode,

}

}

let InferenceResult {

method_resolutions,

field_resolutions,

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

table,

mut result,

result

}

let return_ty = self.make_ty(

data.type_ref,

&data.store,

self.return_ty = return_ty;

}

let return_ty = self.make_ty(

data.type_ref,

&data.store,

fn with_ty_lowering<R>(

&mut self,

types_source: InferenceTyDiagnosticSource,

store_owner: ExpressionStoreOwnerId,

lifetime_elision: LifetimeElisionKind<'db>,

fn make_ty(

&mut self,

type_ref: TypeRefId,

type_source: InferenceTyDiagnosticSource,

store_owner: ExpressionStoreOwnerId,

lifetime_elision: LifetimeElisionKind<'db>,

};

fn forbid_unresolved_segments<'db>(

result: (Ty<'db>, Option<VariantId>),

unresolved: Option<usize>,

) -> (Ty<'db>, Option<VariantId>) {

/// which still is useful, because it informs integer literals and the like.

/// See the test case `test/ui/coerce-expect-unsized.rs` and #20169

/// for examples of where this comes up,.

match ctx.struct_tail_without_normalization(ty).kind() {

TyKind::Slice(_) | TyKind::Str | TyKind::Dynamic(..) => {

Expectation::RValueLikeUnsized(ty)