mod place_op;

pub(crate) mod unify;

use base_db::{Crate, FxIndexMap};

use either::Either;

use hir_expand::{mod_path::ModPath, name::Name};

use indexmap::IndexSet;

use la_arena::ArenaMap;

use rustc_ast_ir::Mutability;

use rustc_hash::{FxHashMap, FxHashSet};

use rustc_type_ir::{

AliasTyKind, TypeFoldable,

};

use smallvec::SmallVec;

use span::Edition;

use thin_vec::ThinVec;

use crate::{

closure_analysis::PlaceBase,

collect_type_inference_vars,

db::{HirDatabase, InternedOpaqueTyId},

diagnostics::{Diagnostics, InferenceTyLoweringContext as TyLoweringContext},

expr::ExprIsRead,

pat::PatOrigin,

},

lower::{

ImplTraitIdx, ImplTraitLoweringMode, LifetimeElisionKind, diagnostics::TyLoweringDiagnostic,

},

method_resolution::CandidateId,

next_solver::{

abi::Safety,

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

},

// Array lengths are always `usize`.

RootExprOrigin::ArrayLength => Expectation::has_type(ctx.types.types.usize),

// Const parameter default: look up the param's declared type.

ConstParamId::from_unchecked(TypeOrConstParamId { parent: def, local_id }),

)),

// Path const generic args: determining the expected type requires

Signature,

}

pub enum InferenceDiagnostic {

NoSuchField {

field: ExprOrPatId,

private: Option<LocalFieldId>,

variant: VariantId,

},

PrivateField {

expr: ExprId,

field: FieldId,

},

PrivateAssocItem {

id: ExprOrPatId,

item: AssocItemId,

},

UnresolvedField {

expr: ExprId,

receiver: StoredTy,

name: Name,

method_with_same_name_exists: bool,

},

UnresolvedMethodCall {

expr: ExprId,

receiver: StoredTy,

name: Name,

/// Contains the type the field resolves to

field_with_same_name: Option<StoredTy>,

assoc_func_with_same_name: Option<FunctionId>,

},

UnresolvedAssocItem {

id: ExprOrPatId,

},

UnresolvedIdent {

id: ExprOrPatId,

},

// FIXME: This should be emitted in body lowering

BreakOutsideOfLoop {

expr: ExprId,

is_break: bool,

bad_value_break: bool,

},

MismatchedArgCount {

call_expr: ExprId,

expected: usize,

found: usize,

},

MismatchedTupleStructPatArgCount {

pat: PatId,

expected: usize,

found: usize,

},

ExpectedFunction {

call_expr: ExprId,

found: StoredTy,

},

TypedHole {

expr: ExprId,

expected: StoredTy,

},

CastToUnsized {

expr: ExprId,

cast_ty: StoredTy,

},

InvalidCast {

expr: ExprId,

error: CastError,

expr_ty: StoredTy,

cast_ty: StoredTy,

},

TyDiagnostic {

source: InferenceTyDiagnosticSource,

diag: TyLoweringDiagnostic,

},

PathDiagnostic {

node: ExprOrPatId,

diag: PathLoweringDiagnostic,

},

MethodCallIncorrectGenericsLen {

expr: ExprId,

provided_count: u32,

expected_count: u32,

kind: IncorrectGenericsLenKind,

def: GenericDefId,

},

MethodCallIncorrectGenericsOrder {

expr: ExprId,

param_id: GenericParamId,

arg_idx: u32,

/// Whether the `GenericArgs` contains a `Self` arg.

has_self_arg: bool,

},

InvalidLhsOfAssignment {

lhs: ExprId,

},

TypeMustBeKnown {

},

}

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

pub struct TypeMismatch {

pub expected: StoredTy,

pub actual: StoredTy,

deferred_call_resolutions: FxHashMap<ExprId, Vec<DeferredCallResolution<'db>>>,

diagnostics: Diagnostics,

}

#[derive(Clone, Debug)]

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

fn resolve_all(self) -> InferenceResult {

let InferenceContext {

mut result,

tuple_field_accesses_rev,

diagnostics,

types,

..

} = self;

// Destructure every single field so whenever new fields are added to `InferenceResult` we

// don't forget to handle them here.

let InferenceResult {

pat_adjustments,

binding_modes: _,

expr_adjustments,

coercion_casts: _,

} = &mut result;

skipped_ref_pats.shrink_to_fit();

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();

}

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 adjustments in pat_adjustments.values_mut() {

for adjustment in &mut *adjustments {

}

adjustments.shrink_to_fit();

}

};

for (place, _, sources) in fake_reads {

place.projections.shrink_to_fit();

for source in &mut *sources {

source.shrink_to_fit();

for min_capture in min_captures.values_mut() {

for captured in &mut *min_capture {

let CapturedPlace { place, info, mutability: _ } = captured;

let CaptureInfo { sources, capture_kind: _ } = info;

for source in &mut *sources {

source.shrink_to_fit();

min_captures.shrink_to_fit();

}

closures_data.shrink_to_fit();

.into_iter()

})

.collect();

result

}

&data.store,

InferenceTyDiagnosticSource::Signature,

LifetimeElisionKind::for_const(self.interner(), id.loc(self.db).container),

);

self.return_ty = return_ty;

&data.store,

InferenceTyDiagnosticSource::Signature,

LifetimeElisionKind::Elided(self.types.regions.statik),

);

self.return_ty = return_ty;

GenericArgs::for_item_with_defaults(

self.interner(),

va_list.into(),

),

),

None => self.err_ty(),

param_tys.push(va_list_ty);

}

if let Some(self_param) = self_param

&& let Some(ty) = param_tys.next()

{

self.write_binding_ty(self_param, ty);

}

self.infer_top_pat(*pat, ty, PatOrigin::Param);

}

ctx.lower_ty(return_ty)

},

);

}

None => self.types.types.unit,

};

/// but if we return a new var, mark it so that no diagnostics will be issued on it.

fn insert_type_vars_shallow(&mut self, ty: Ty<'db>) -> Ty<'db> {

if ty.is_ty_error() {

// Suppress future errors on this var. Add more things here when we add more diagnostics.

var

} else {

}

}

fn infer_body(&mut self, body_expr: ExprId) {

match self.return_coercion {

Some(_) => self.infer_return(body_expr),

store: &ExpressionStore,

type_source: InferenceTyDiagnosticSource,

lifetime_elision: LifetimeElisionKind<'db>,

) -> Ty<'db> {

let ty = self

.with_ty_lowering(store, type_source, lifetime_elision, |ctx| ctx.lower_ty(type_ref));

// Record the association from placeholders' TypeRefId to type variables.

// We only record them if their number matches. This assumes TypeRef::walk and TypeVisitable process the items in the same order.

self.store,

InferenceTyDiagnosticSource::Body,

LifetimeElisionKind::Infer,

)

}

LifetimeElisionKind::Infer,

|ctx| ctx.lower_const(const_ref, ty),

);

}

let const_ = self.with_ty_lowering(

self.store,

InferenceTyDiagnosticSource::Body,

LifetimeElisionKind::Infer,

|ctx| ctx.lower_path_as_const(path, ty),

);

}

fn err_ty(&self) -> Ty<'db> {

LifetimeElisionKind::Infer,

|ctx| ctx.lower_lifetime(lifetime_ref),

);

}

where

T: TypeFoldable<DbInterner<'db>>,

{

}

/// Attempts to returns the deeply last field of nested structures, but

}

/// Whenever you lower a user-written type, you should call this.

}

/// The difference of this method from `process_user_written_ty()` is that this method doesn't register a well-formed obligation,

node: ExprOrPatId,

ty: Ty<'db>,

) -> Ty<'db> {

}

self.types.types.error

}

return (self.err_ty(), None);

}

let (mut ty, type_ns) = ctx.lower_ty_ext(type_anchor);

if let Some(TypeNs::SelfType(impl_)) = type_ns

&& let Some(trait_ref) = self.db.impl_trait(impl_)

.associated_type_by_name(segments.first().unwrap().name)

{

// `<Self>::AssocType`

let alias = Ty::new_alias(

self.interner(),

AliasTy::new_from_args(

.db

.ty(var.lookup(self.db).parent.into())

.instantiate(interner, args);

return (ty, Some(var.into()));

}

ValueNs::StructId(strukt) => {

let args = path_ctx.substs_from_path(strukt.into(), true, false);

drop(ctx);

let ty = self.db.ty(strukt.into()).instantiate(interner, args);

return (ty, Some(strukt.into()));

}

ValueNs::ImplSelf(impl_id) => (TypeNs::SelfType(impl_id), None),

let args = path_ctx.substs_from_path(strukt.into(), true, false);

drop(ctx);

let ty = self.db.ty(strukt.into()).instantiate(interner, args);

forbid_unresolved_segments(self, (ty, Some(strukt.into())), unresolved)

}

TypeNs::AdtId(AdtId::UnionId(u)) => {

let args = path_ctx.substs_from_path(u.into(), true, false);

drop(ctx);

let ty = self.db.ty(u.into()).instantiate(interner, args);

forbid_unresolved_segments(self, (ty, Some(u.into())), unresolved)

}

TypeNs::EnumVariantId(var) => {

let args = path_ctx.substs_from_path(var.into(), true, false);

drop(ctx);

let ty = self.db.ty(var.lookup(self.db).parent.into()).instantiate(interner, args);

forbid_unresolved_segments(self, (ty, Some(var.into())), unresolved)

}

TypeNs::SelfType(impl_id) => {

(ty, _) = path_ctx.lower_partly_resolved_path(resolution, true);

tried_resolving_once = true;

if ty.is_ty_error() {

return (self.err_ty(), None);

}

}

let (mut ty, _) = path_ctx.lower_partly_resolved_path(resolution, true);

if let Some(segment) = remaining_segments.get(1)

&& let Some((AdtId::EnumId(id), _)) = ty.as_adt()

drop(ctx);

let interner = DbInterner::conjure();

let ty = self.db.ty(it.into()).instantiate(interner, args);

self.resolve_variant_on_alias(ty, unresolved, mod_path)

}

}

}

}

/// Comment copied from rustc: