//! to certain types. To record this, we use the union-find implementation from

//! the `ena` crate, which is extracted from rustc.

pub(crate) mod cast;

pub(crate) mod closure;

mod coerce;

use std::{cell::OnceCell, convert::identity, iter, ops::Index};

use chalk_ir::{

DebruijnIndex, Mutability, Safety, Scalar, TyKind, TypeFlags, Variance,

cast::Cast,

use stdx::{always, never};

use triomphe::Arc;

use crate::{

AliasEq, AliasTy, Binders, ClosureId, Const, DomainGoal, GenericArg, ImplTraitId, ImplTraitIdx,

IncorrectGenericsLenKind, Interner, Lifetime, OpaqueTyId, ParamLoweringMode,

db::HirDatabase,

fold_tys,

generics::Generics,

infer::{

diagnostics::{Diagnostics, InferenceTyLoweringContext as TyLoweringContext},

expr::ExprIsRead,

unify::InferenceTable,

},

lower::{ImplTraitLoweringMode, LifetimeElisionKind, diagnostics::TyLoweringDiagnostic},

mir::MirSpan,

static_lifetime, to_assoc_type_id,

traits::FnTrait,

};

// This lint has a false positive here. See the link below for details.

pub use unify::{could_unify, could_unify_deeply};

use cast::{CastCheck, CastError};

/// The entry point of type inference.

pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {

let mut table = unify::InferenceTable::new(db, trait_env);

let ty_with_vars = table.normalize_associated_types_in(ty);

table.propagate_diverging_flag();

table.resolve_completely(ty_with_vars)

}

}

}

#[derive(Debug)]

pub(crate) struct InferOk<'db, T> {

value: T,

goals: Vec<next_solver::Goal<'db, next_solver::Predicate<'db>>>,

}

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

pub enum InferenceTyDiagnosticSource {

/// Diagnostics that come from types in the body.

}

}

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

pub enum Adjust {

/// Go from ! to any type.

/// call, with the signature `&'a T -> &'a U` or `&'a mut T -> &'a mut U`.

/// The target type is `U` in both cases, with the region and mutability

/// being those shared by both the receiver and the returned reference.

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]

pub struct OverloadedDeref(pub Option<Mutability>);

/// 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) resolver: Resolver<'db>,

generic_def: GenericDefId,

generics: OnceCell<Generics>,

table: unify::InferenceTable<'db>,

/// If `Some`, this stores coercion information for returned

/// expressions. If `None`, this is in a context where return is

/// inappropriate, such as a const expression.

/// The resume type and the yield type, respectively, of the coroutine being inferred.

resume_yield_tys: Option<(Ty, Ty)>,

diverges: Diverges,

/// Whether we are inside the pattern of a destructuring assignment.

inside_assignment: bool,

/// We do that because sometimes we truncate projections (when a closure captures

/// both `a.b` and `a.b.c`), and we want to provide accurate spans in this case.

current_capture_span_stack: Vec<MirSpan>,

/// Stores the list of closure ids that need to be analyzed before this closure. See the

/// comment on `InferenceContext::sort_closures`

diagnostics: Diagnostics,

}

#[derive(Clone, Debug)]

/// Whether this context contains at least one break expression.

may_break: bool,

/// The coercion target of the context.

/// The optional label of the context.

label: Option<LabelId>,

kind: BreakableKind,

Border,

}

label: Option<LabelId>,

let mut ctxs = ctxs

.iter_mut()

.rev()

}

}

label: Option<LabelId>,

match label {

Some(_) => find_breakable(ctxs, label).filter(|it| matches!(it.kind, BreakableKind::Loop)),

None => find_breakable(ctxs, label),

) -> Self {

let trait_env = db.trait_environment_for_body(owner);

InferenceContext {

generics: OnceCell::new(),

result: InferenceResult::default(),

table: unify::InferenceTable::new(db, trait_env),

self.generics.get_or_init(|| crate::generics::generics(self.db, self.generic_def))

}

// FIXME: This function should be private in module. It is currently only used in the consteval, since we need

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

} = self;

let mut diagnostics = diagnostics.finish();

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

closure_info: _,

mutated_bindings_in_closure: _,

tuple_field_access_types: _,

diagnostics: _,

} = &mut result;

// FIXME resolve obligations as well (use Guidance if necessary)

// make sure diverging type variables are marked as such

table.propagate_diverging_flag();

};

self.return_ty = self.process_user_written_ty(return_ty);

// Functions might be defining usage sites of TAITs.

// To define an TAITs, that TAIT must appear in the function's signatures.

fold_tys(

t,

|ty, _| {

let opaque_ty_id = match ty.kind(Interner) {

_ => return ty,

};

let (impl_traits, idx) =

ty: &chalk_ir::Ty<Interner>,

outer_binder: DebruijnIndex,

) -> std::ops::ControlFlow<Self::BreakTy> {

&& let ImplTraitId::TypeAliasImplTrait(alias_id, _) =

self.db.lookup_intern_impl_trait_id((*id).into())

{

}

}

fn write_method_resolution(&mut self, expr: ExprId, func: FunctionId, subst: Substitution) {

self.result.method_resolutions.insert(expr, (func, subst));

}

self.table.process_remote_user_written_ty(ty)

}

fn resolve_ty_shallow(&mut self, ty: &Ty) -> Ty {

self.table.resolve_ty_shallow(ty)

}

fn resolve_associated_type(&mut self, inner_ty: Ty, assoc_ty: Option<TypeAliasId>) -> Ty {

self.resolve_associated_type_with_params(inner_ty, assoc_ty, &[])

}