//! Unification and canonicalization logic.

use chalk_ir::{

CanonicalVarKind, FloatTy, IntTy, TyVariableKind, cast::Cast, fold::TypeFoldable,

use hir_expand::name::Name;

use intern::sym;

use rustc_hash::{FxHashMap, FxHashSet};

use rustc_type_ir::{

relate::{Relate, solver_relating::RelateExt},

};

use smallvec::SmallVec;

use triomphe::Arc;

use crate::{

consteval::unknown_const,

db::HirDatabase,

fold_generic_args, fold_tys_and_consts,

next_solver::{

},

to_chalk_trait_id,

traits::{

{

self.table.canonicalize(t)

}

}

}

let ty2_with_vars = vars.apply(tys.value.1.clone(), Interner);

let ty1_with_vars = table.normalize_associated_types_in(ty1_with_vars);

let ty2_with_vars = table.normalize_associated_types_in(ty2_with_vars);

table.propagate_diverging_flag();

let ty1_with_vars = table.resolve_completely(ty1_with_vars);

let ty2_with_vars = table.resolve_completely(ty2_with_vars);

}

#[derive(Clone)]

pub(crate) trait_env: Arc<TraitEnvironment>,

pub(crate) tait_coercion_table: Option<FxHashMap<OpaqueTyId, Ty>>,

diverging_tys: FxHashSet<Ty>,

}

ctxt_snapshot: CombinedSnapshot,

diverging_tys: FxHashSet<Ty>,

}

let interner = DbInterner::new_with(db, Some(trait_env.krate), trait_env.block);

InferenceTable {

db,

interner,

trait_env,

tait_coercion_table: None,

diverging_tys: FxHashSet::default(),

}

}

.intern(Interner)

}

where

{

// try to resolve obligations before canonicalizing, since this might

// result in new knowledge about variables

self.infer_ctxt.canonicalize_response(t)

}

/// to do it as well.

pub(crate) fn normalize_associated_types_in<T, U>(&mut self, ty: T) -> T

where

{

self.normalize_associated_types_in_ns(ty.to_nextsolver(self.interner))

.to_chalk(self.interner)

}

pub(crate) fn normalize_associated_types_in_ns<T>(&mut self, ty: T) -> T

where

{

let ty = self.resolve_vars_with_obligations(ty);

}

/// Works almost same as [`Self::normalize_associated_types_in`], but this also resolves shallow

pub(crate) fn normalize_alias_ty(

&mut self,

let infer_term = self.infer_ctxt.next_ty_var();

let obligation = crate::next_solver::Predicate::new(

self.interner,

self.new_var(TyVariableKind::General, false)

}

pub(crate) fn new_integer_var(&mut self) -> Ty {

self.new_var(TyVariableKind::Integer, false)

}

var.to_lifetime(Interner)

}

pub(crate) fn resolve_with_fallback<T>(

&mut self,

t: T,

pub(crate) fn instantiate_canonical_ns<T>(

&mut self,

) -> T

where

{

self.infer_ctxt.instantiate_canonical(&canonical).0

}

pub(crate) fn resolve_completely<T, U>(&mut self, t: T) -> T

where

{

let t = self.resolve_with_fallback(t, &|_, _, d, _| d);

let t = self.normalize_associated_types_in(t);

}

/// Unify two relatable values (e.g. `Ty`) and register new trait goals that arise from that.

&mut self,

ty1: &T,

ty2: &T,

Ok(r) => r,

Err(_) => return false,

};

true

}

/// Unify two relatable values (e.g. `Ty`) and check whether trait goals which arise from that could be fulfilled

&mut self,

ty1: &T,

ty2: &T,

/// Unify two relatable values (e.g. `Ty`) and return new trait goals arising from it, so the

/// caller needs to deal with them.

&mut self,

t1: &T,

t2: &T,

let lhs = t1.to_nextsolver(self.interner);

let rhs = t2.to_nextsolver(self.interner);

let variance = rustc_type_ir::Variance::Invariant;

let span = crate::next_solver::Span::dummy();

Err(_) => Err(TypeError),

}

}

/// otherwise, return ty.

#[tracing::instrument(skip(self))]

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

}

pub(crate) fn resolve_vars_with_obligations<T>(&mut self, t: T) -> T

where

{

use rustc_type_ir::TypeVisitableExt;

return t;

}

self.infer_ctxt.resolve_vars_if_possible(t)

}

.to_chalk(self.interner)

}

}

let ctxt_snapshot = self.infer_ctxt.start_snapshot();

let diverging_tys = self.diverging_tys.clone();

}

#[tracing::instrument(skip_all)]

self.infer_ctxt.rollback_to(snapshot.ctxt_snapshot);

self.diverging_tys = snapshot.diverging_tys;

}

#[tracing::instrument(skip_all)]

let snapshot = self.snapshot();

let result = f(self);

self.rollback_to(snapshot);

pub(crate) fn commit_if_ok<T, E>(

&mut self,

) -> Result<T, E> {

let snapshot = self.snapshot();

let result = f(self);

result.map(|m| m.1)

}

let goal = next_solver::Goal {

param_env: self.trait_env.env.to_nextsolver(self.interner),

predicate,

#[tracing::instrument(level = "debug", skip(self))]

fn register_obligation_in_env(

&mut self,

) {

let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal);

tracing::debug!(?result);

Ok((_, Certainty::Yes)) => {}

Err(rustc_type_ir::solve::NoSolution) => {}

Ok((_, Certainty::Maybe(_))) => {

}

}

}

}

}

&mut self,

}

}

pub(crate) fn callable_sig(

&mut self,

ty: &Ty,

num_args: usize,

match ty.callable_sig(self.db) {

None => {

let (f, args_ty, return_ty) = self.callable_sig_from_fn_trait(ty, num_args)?;

Some((Some(f), args_ty, return_ty))

&mut self,

ty: &Ty,

num_args: usize,

for (fn_trait_name, output_assoc_name, subtraits) in [

(FnTrait::FnOnce, sym::Output, &[FnTrait::Fn, FnTrait::FnMut][..]),

(FnTrait::AsyncFnMut, sym::CallRefFuture, &[FnTrait::AsyncFn]),

ParamKind::Lifetime => unreachable!("Tuple with lifetime parameter"),

ParamKind::Const(_) => unreachable!("Tuple with const parameter"),

};

arg.cast(Interner)

})

.build();

let goal: Goal = trait_ref.clone().cast(Interner);

if !self.try_obligation(goal.clone()).no_solution() {

self.register_obligation(goal.to_nextsolver(self.interner));

for &fn_x in subtraits {

let fn_x_trait = fn_x.get_id(self.db, krate)?;

trait_ref.trait_id = to_chalk_trait_id(fn_x_trait);

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

pub(crate) fn process_user_written_ty<T, U>(&mut self, ty: T) -> T

where

{

self.process_remote_user_written_ty(ty)

// FIXME: Register a well-formed obligation.

/// while `process_user_written_ty()` should (but doesn't currently).

pub(crate) fn process_remote_user_written_ty<T, U>(&mut self, ty: T) -> T

where

{

let ty = self.insert_type_vars(ty);

// See https://github.com/rust-lang/rust/blob/cdb45c87e2cd43495379f7e867e3cc15dcee9f93/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs#L487-L495:

// Even though the new solver only lazily normalizes usually, here we eagerly normalize so that not everything needs

// to normalize before inspecting the `TyKind`.

self.normalize_associated_types_in(ty)

}

impl fmt::Debug for InferenceTable<'_> {

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

}

}

};

use rustc_type_ir::{FloatVid, IntVid, TyVid};

pub(super) enum VarKind {

Ty(TyVariableKind),

Const,

}

}

}