+ mapping::{ChalkToNextSolver, convert_binder_to_early_binder},

+ let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);

+ let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);

+ if !self.table.unify::<_, crate::next_solver::GenericArgs<'_>>(&expected_sig.substitution.0, &supplied_sig.expected_sig.substitution.0) {

+use chalk_ir::{BoundVar, Mutability, TyKind, TyVariableKind, cast::Cast};

+use hir_def::{

+ hir::ExprId,

+ lang_item::LangItem,

+};

+use rustc_type_ir::solve::Certainty;

+ autoderef::{Autoderef, AutoderefKind}, db::HirDatabase, infer::{

+ }, utils::ClosureSubst, Canonical, FnAbi, FnPointer, FnSig, Goal, InEnvironment, Interner, Lifetime, Substitution, TraitEnvironment, Ty, TyBuilder, TyExt

+ goals: Vec<InEnvironment<Goal>>,

+ self.set_diverging(*tv, TyVariableKind::General, true);

+ let goal: Goal = coerce_unsized_tref.cast(Interner);

+

+ self.commit_if_ok(|table| {

+ match table.solve_obligation(goal) {

+ Ok(Certainty::Yes) => Ok(()),

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

+ Err(_) => Err(TypeError),

+ })?;

+ autoderef::{builtin_deref, deref_by_trait, Autoderef}, consteval, generics::generics, infer::{

+ coerce::{CoerceMany, CoerceNever, CoercionCause}, find_continuable, pat::contains_explicit_ref_binding, BreakableKind

+ }, lang_items::lang_items_for_bin_op, lower::{lower_to_chalk_mutability, path::{substs_from_args_and_bindings, GenericArgsLowerer, TypeLikeConst}, ParamLoweringMode}, mapping::{from_chalk, ToChalk}, method_resolution::{self, VisibleFromModule}, next_solver::mapping::ChalkToNextSolver, primitive::{self, UintTy}, static_lifetime, to_chalk_trait_id, traits::FnTrait, Adjust, Adjustment, AdtId, AutoBorrow, Binders, CallableDefId, CallableSig, DeclContext, DeclOrigin, IncorrectGenericsLenKind, Interner, LifetimeElisionKind, Rawness, Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind

+ let canonicalized = ChalkToNextSolver::from_nextsolver(self.canonicalize(base_ty.clone().to_nextsolver(self.table.interner)), self.table.interner);

+ tracing::debug!(?expected_ty);

+ let canonicalized_receiver = self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));

+ let canonicalized_receiver = self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));

+ builder::ParamKind, consteval, error_lifetime, generics::generics, infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext, method_resolution::{self, VisibleFromModule}, next_solver::mapping::ChalkToNextSolver, to_chalk_trait_id, InferenceDiagnostic, Interner, LifetimeElisionKind, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, ValueTyDefId

+ let canonical_ty = self.canonicalize(ty.clone().to_nextsolver(self.table.interner));

+ cast::Cast, fold::TypeFoldable, interner::HasInterner, CanonicalVarKind, FloatTy, IntTy, TyVariableKind,

+use rustc_hash::{FxHashMap, FxHashSet};

+use rustc_next_trait_solver::solve::HasChanged;

+use rustc_type_ir::{inherent::Span, relate::{solver_relating::RelateExt, Relate}, solve::{Certainty, NoSolution}, FloatVid, IntVid, TyVid};

+ consteval::unknown_const, db::HirDatabase, fold_generic_args, fold_tys_and_consts, next_solver::{infer::{canonical::canonicalizer::OriginalQueryValues, snapshot::CombinedSnapshot, DbInternerInferExt, InferCtxt}, mapping::{ChalkToNextSolver, InferenceVarExt}, DbInterner, ParamEnvAnd, SolverDefIds}, to_chalk_trait_id, traits::{next_trait_solve, next_trait_solve_canonical, next_trait_solve_in_ctxt, FnTrait, NextTraitSolveResult}, AliasEq, AliasTy, BoundVar, Canonical, Const, ConstValue, DebruijnIndex, DomainGoal, GenericArg, GenericArgData, Goal, GoalData, InEnvironment, InferenceVar, Interner, Lifetime, OpaqueTyId, ParamKind, ProjectionTy, ProjectionTyExt, Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind, VariableKind, WhereClause

+impl<'db> InferenceContext<'db> {

+ pub(super) fn canonicalize<T>(&mut self, t: T) -> rustc_type_ir::Canonical<DbInterner<'db>, T>

+ T: rustc_type_ir::TypeFoldable<DbInterner<'db>>,

+ let root = InferenceVar::from_vid(self.table.infer_ctxt.root_var(self_ty.to_vid()));

+ .filter_map(|obligation| match obligation.goal.data(Interner) {

+ let ty = self.resolve_ty_shallow(&ty);

+ if matches!(ty.kind(Interner), TyKind::InferenceVar(iv, TyVariableKind::General) if *iv == root) {

+ Some(clause.clone())

+ pub(crate) interner: DbInterner<'a>,

+ infer_ctxt: InferCtxt<'a>,

+ diverging_tys: FxHashSet<Ty>,

+ pending_obligations: Vec<InEnvironment<Goal>>,

+ ctxt_snapshot: CombinedSnapshot,

+ diverging_tys: FxHashSet<Ty>,

+ pending_obligations: Vec<InEnvironment<Goal>>,

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

+ interner,

+ infer_ctxt: interner.infer_ctxt().build(rustc_type_ir::TypingMode::Analysis { defining_opaque_types_and_generators: SolverDefIds::new_from_iter(interner, []) }),

+ diverging_tys: FxHashSet::default(),

+ let mut new_tys = FxHashSet::default();

+ for ty in self.diverging_tys.iter() {

+ match ty.kind(Interner) {

+ TyKind::InferenceVar(var, kind) => {

+ match kind {

+ TyVariableKind::General => {

+ let root = InferenceVar::from(self.infer_ctxt.root_var(TyVid::from_u32(var.index())).as_u32());

+ if root.index() != var.index() {

+ new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));

+ }

+ }

+ TyVariableKind::Integer => {

+ let root = InferenceVar::from(self.infer_ctxt.inner.borrow_mut().int_unification_table().find(IntVid::from_usize(var.index() as usize)).as_u32());

+ if root.index() != var.index() {

+ new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));

+ }

+ }

+ TyVariableKind::Float => {

+ let root = InferenceVar::from(self.infer_ctxt.inner.borrow_mut().float_unification_table().find(FloatVid::from_usize(var.index() as usize)).as_u32());

+ if root.index() != var.index() {

+ new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));

+ }

+ }

+ }

+ }

+ _ => {}

+ self.diverging_tys.extend(new_tys.into_iter());

+ pub(super) fn set_diverging(&mut self, iv: InferenceVar, kind: TyVariableKind, diverging: bool) {

+ self.diverging_tys.insert(TyKind::InferenceVar(iv, kind).intern(Interner));

+ let is_diverging = self.diverging_tys.contains(&TyKind::InferenceVar(iv, kind).intern(Interner));

+ pub(crate) fn canonicalize_with_free_vars<T>(&mut self, t: ParamEnvAnd<'a, T>) -> (rustc_type_ir::Canonical<DbInterner<'a>, ParamEnvAnd<'a, T>>, OriginalQueryValues<'a>)

+ T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,

+

+ let mut orig_values = OriginalQueryValues::default();

+ let result = self.infer_ctxt.canonicalize_query(t, &mut orig_values);

+ (result.canonical, orig_values)

+ pub(crate) fn canonicalize<T>(&mut self, t: T) -> rustc_type_ir::Canonical<DbInterner<'a>, T>

+ T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,

+ self.infer_ctxt.canonicalize_response(t)

+ return Either::Left(self.resolve_ty_shallow(&ty));

+ let goal = in_env.to_nextsolver(self.interner);

+ let goal = ParamEnvAnd { param_env: goal.param_env, value: goal.predicate };

+ let (canonical_goal, _orig_values) = {

+ let mut orig_values = OriginalQueryValues::default();

+ let result = self.infer_ctxt.canonicalize_query(goal, &mut orig_values);

+ (result.canonical, orig_values)

+ };

+ let canonical_goal = rustc_type_ir::Canonical {

+ max_universe: canonical_goal.max_universe,

+ variables: canonical_goal.variables,

+ value: crate::next_solver::Goal { param_env: canonical_goal.value.param_env, predicate: canonical_goal.value.value },

+ let solution = next_trait_solve_canonical(

+ self.db,

+ canonical_goal.clone(),

+ let var = match kind {

+ TyVariableKind::General => {

+ let var = self.infer_ctxt.next_ty_vid();

+ InferenceVar::from(var.as_u32())

+ }

+ TyVariableKind::Integer => {

+ let var = self.infer_ctxt.next_int_vid();

+ InferenceVar::from(var.as_u32())

+ }

+ TyVariableKind::Float => {

+ let var = self.infer_ctxt.next_float_vid();

+ InferenceVar::from(var.as_u32())

+ }

+ };

+

+ let ty = var.to_ty(Interner, kind);

+ self.diverging_tys.insert(ty.clone());

+ ty

+ let var = self.infer_ctxt.next_const_vid();

+ let var = InferenceVar::from(var.as_u32());

+ let var = self.infer_ctxt.next_region_vid();

+ let var = InferenceVar::from(var.as_u32());

+ self.resolve_with_fallback_inner(t, &fallback)

+ binders.iter().map(|kind| match &kind.kind {

+ chalk_ir::VariableKind::Ty(ty_variable_kind) => self.new_var(*ty_variable_kind, false).cast(Interner),

+ chalk_ir::VariableKind::Lifetime => self.new_lifetime_var().cast(Interner),

+ chalk_ir::VariableKind::Const(ty) => self.new_const_var(ty.clone()).cast(Interner),

+

+ pub(crate) fn instantiate_canonical_ns<T>(&mut self, canonical: rustc_type_ir::Canonical<DbInterner<'a>, T>) -> T

+ where

+ T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,

+ {

+ self.infer_ctxt.instantiate_canonical(&canonical).0

+ }

+ let mut var_stack = &mut vec![];

+ let int_vars = self.infer_ctxt.inner.borrow_mut().int_unification_table().len();

+ for v in 0..int_vars {

+ let var = InferenceVar::from(v as u32).to_ty(Interner, TyVariableKind::Integer);

+ let maybe_resolved = self.resolve_ty_shallow(&var);

+ if let TyKind::InferenceVar(_, kind) = maybe_resolved.kind(Interner) {

+ // I don't think we can ever unify these vars with float vars, but keep this here for now

+ let fallback = match kind {

+ TyVariableKind::Integer => &int_fallback,

+ TyVariableKind::Float => &float_fallback,

+ TyVariableKind::General => unreachable!(),

+ self.unify(&var, fallback);

+ }

+ }

+ let float_vars = self.infer_ctxt.inner.borrow_mut().float_unification_table().len();

+ for v in 0..float_vars {

+ let var = InferenceVar::from(v as u32).to_ty(Interner, TyVariableKind::Integer);

+ // I don't think we can ever unify these vars with float vars, but keep this here for now

+ pub(crate) fn unify<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(&mut self, ty1: &T, ty2: &T) -> bool {

+ pub(crate) fn unify_deeply<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(&mut self, ty1: &T, ty2: &T) -> bool {

+ let goal = goal.to_nextsolver(self.interner);

+ match next_trait_solve_in_ctxt(&self.infer_ctxt, goal) {

+ Ok((_, Certainty::Yes)) => true,

+ _ => false,

+ }

+ pub(crate) fn try_unify<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(

+ let param_env = self.trait_env.env.to_nextsolver(self.interner);

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

+ match self.infer_ctxt.relate(param_env, lhs, variance, rhs, span) {

+ Ok(res) => {

+ let goals = res.into_iter().map(|g| ChalkToNextSolver::from_nextsolver(g, self.interner)).collect();

+ Ok(InferOk { goals, value: () })

+ }

+ Err(_) => {

+ Err(TypeError)

+ }

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

+ ChalkToNextSolver::from_nextsolver(self.infer_ctxt.resolve_vars_if_possible(ty.to_nextsolver(self.interner)), self.interner)

+ let ctxt_snapshot = self.infer_ctxt.start_snapshot();

+ let diverging_tys = self.diverging_tys.clone();

+ InferenceTableSnapshot {ctxt_snapshot, pending_obligations, diverging_tys }

+ self.infer_ctxt.rollback_to(snapshot.ctxt_snapshot);

+ self.diverging_tys = snapshot.diverging_tys;

+ pub(crate) fn commit_if_ok<T, E>(&mut self, f: impl FnOnce(&mut InferenceTable<'_>) -> Result<T, E>) -> Result<T, E> {

+ let snapshot = self.snapshot();

+ let result = f(self);

+ match result {

+ Ok(_) => {}

+ Err(_) => {

+ self.rollback_to(snapshot);

+ }

+ }

+ result

+ }

+

+ let canonicalized = self.canonicalize(in_env.to_nextsolver(self.interner));

+ next_trait_solve_canonical(self.db, self.trait_env.krate, self.trait_env.block, canonicalized)

+ }

+

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

+ pub(crate) fn solve_obligation(&mut self, goal: Goal) -> Result<Certainty, NoSolution> {

+ let goal = InEnvironment::new(&self.trait_env.env, goal);

+ let Some(goal) = self.unify_opaque_instead_of_solve(goal) else {

+ return Ok(Certainty::Yes);

+ };

+

+ let goal = goal.to_nextsolver(self.interner);

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

+ result.map(|m| m.1)

+ // If this goal is an `AliasEq` for an opaque type, just unify instead of trying to solve (since the next-solver is lazy)

+ fn unify_opaque_instead_of_solve(&mut self, goal: InEnvironment<Goal>) -> Option<InEnvironment<Goal>> {

+ return None;

+ Some(goal)

+ }

+

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

+ fn register_obligation_in_env(&mut self, goal: InEnvironment<Goal>) {

+ let Some(goal) = self.unify_opaque_instead_of_solve(goal) else { return };

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

+ tracing::debug!(?result);

+ match result {

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

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

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

+ self.pending_obligations.push(goal);

+ }

+ let mut obligations = mem::take(&mut self.pending_obligations);

+ for goal in obligations.drain(..) {

+ tracing::debug!(obligation = ?goal);

+

+ let Some(goal) = self.unify_opaque_instead_of_solve(goal) else {

+ changed = true;

+ };

+

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

+ let (has_changed, certainty) = match result {

+ Ok(result) => result,

+ Err(_) => {

+ continue;

+ }

+ };

+

+ if matches!(has_changed, HasChanged::Yes) {

+ changed = true;

+ }

+

+ match certainty {

+ Certainty::Yes => {}

+ Certainty::Maybe(_) => self.pending_obligations.push(goal),

+ let solution = next_trait_solve(

+ self.db,

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

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

+ self.register_obligation(goal);

+ let goal = trait_ref.clone().cast(Interner);

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

+ f.debug_struct("InferenceTable").finish()

+ next_solver::mapping::ChalkToNextSolver, ConcreteConst, Const, ConstData, ConstScalar, ConstValue, DebruijnIndex, GenericArg, InferenceVar, Interner, Lifetime, Ty, TyVariableKind, VariableKind

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

+

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

+ pub(super) enum VarKind {

+ Ty(TyVariableKind),

+ Const,

+ }

+ pub(super) var_stack: &'a mut Vec<(InferenceVar, VarKind)>,

+ match kind {

+ TyVariableKind::General => {

+ let vid = self.table.infer_ctxt.root_var(TyVid::from(var.index()));

+ let var = InferenceVar::from(vid.as_u32());

+ if self.var_stack.contains(&(var, VarKind::Ty(kind))) {

+ // recursive type

+ let default = self.table.fallback_value(var, kind).cast(Interner);

+ return (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)

+ .assert_ty_ref(Interner)

+ .clone();

+ }

+ if let Ok(known_ty) = self.table.infer_ctxt.probe_ty_var(vid) {

+ let known_ty: Ty = ChalkToNextSolver::from_nextsolver(known_ty, self.table.interner);

+ // known_ty may contain other variables that are known by now

+ self.var_stack.push((var, VarKind::Ty(kind)));

+ let result = known_ty.fold_with(self, outer_binder);

+ self.var_stack.pop();

+ result

+ } else {

+ let default = self.table.fallback_value(var, kind).cast(Interner);

+ (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)

+ .assert_ty_ref(Interner)

+ .clone()

+ }

+ }

+ TyVariableKind::Integer => {

+ let vid = self.table.infer_ctxt.inner.borrow_mut().int_unification_table().find(IntVid::from(var.index()));

+ let var = InferenceVar::from(vid.as_u32());

+ if self.var_stack.contains(&(var, VarKind::Ty(kind))) {

+ // recursive type

+ let default = self.table.fallback_value(var, kind).cast(Interner);

+ return (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)

+ .assert_ty_ref(Interner)

+ .clone();

+ }

+ if let Some(known_ty) = self.table.infer_ctxt.resolve_int_var(vid) {

+ let known_ty: Ty = ChalkToNextSolver::from_nextsolver(known_ty, self.table.interner);

+ // known_ty may contain other variables that are known by now

+ self.var_stack.push((var, VarKind::Ty(kind)));

+ let result = known_ty.fold_with(self, outer_binder);

+ self.var_stack.pop();

+ result

+ } else {

+ let default = self.table.fallback_value(var, kind).cast(Interner);

+ (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)

+ .assert_ty_ref(Interner)

+ .clone()

+ }

+ }

+ TyVariableKind::Float => {

+ let vid = self.table.infer_ctxt.inner.borrow_mut().float_unification_table().find(FloatVid::from(var.index()));

+ let var = InferenceVar::from(vid.as_u32());

+ if self.var_stack.contains(&(var, VarKind::Ty(kind))) {

+ // recursive type

+ let default = self.table.fallback_value(var, kind).cast(Interner);

+ return (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)

+ .assert_ty_ref(Interner)

+ .clone();

+ }

+ if let Some(known_ty) = self.table.infer_ctxt.resolve_float_var(vid) {

+ let known_ty: Ty = ChalkToNextSolver::from_nextsolver(known_ty, self.table.interner);

+ // known_ty may contain other variables that are known by now

+ self.var_stack.push((var, VarKind::Ty(kind)));

+ let result = known_ty.fold_with(self, outer_binder);

+ self.var_stack.pop();

+ result

+ } else {

+ let default = self.table.fallback_value(var, kind).cast(Interner);

+ (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)

+ .assert_ty_ref(Interner)

+ .clone()

+ }

+ }

+ let vid = self.table.infer_ctxt.root_const_var(rustc_type_ir::ConstVid::from_u32(var.index()));

+ let var = InferenceVar::from(vid.as_u32());

+ if self.var_stack.contains(&(var, VarKind::Const)) {

+ if let Ok(known_const) = self.table.infer_ctxt.probe_const_var(vid) {

+ let known_const: Const = ChalkToNextSolver::from_nextsolver(known_const, self.table.interner);

+ self.var_stack.push((var, VarKind::Const));

+ let result = known_const.fold_with(self, outer_binder);

+ result

+ if !table.try_obligation(trait_ref.clone().cast(Interner)).no_solution() {

+ table.register_obligation(trait_ref.clone().cast(Interner));

+ if !table.try_obligation(trait_ref.clone().cast(Interner)).no_solution() {

+use rustc_type_ir::inherent::{IntoKind, SliceLike, Ty as _};

+ autoderef::{self, AutoderefKind}, db::HirDatabase, from_chalk_trait_id, from_foreign_def_id, infer::{unify::InferenceTable, Adjust, Adjustment, OverloadedDeref, PointerCast}, lang_items::is_box, next_solver::{mapping::ChalkToNextSolver, SolverDefId}, primitive::{FloatTy, IntTy, UintTy}, to_chalk_trait_id, traits::{next_trait_solve_canonical}, utils::all_super_traits, AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId, GenericArgData, Goal, InEnvironment, Interner, Mutability, Scalar, Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, TyVariableKind, VariableKind, WhereClause

+pub(crate) fn lookup_method<'db>(

+ db: &'db dyn HirDatabase,

+ ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,

+pub(crate) fn iterate_method_candidates<'db, T>(

+ ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,

+ db: &'db dyn HirDatabase,

+pub fn iterate_path_candidates<'db>(

+ ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,

+ db: &'db dyn HirDatabase,

+pub fn iterate_method_candidates_dyn<'db>(

+ ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,

+ db: &'db dyn HirDatabase,

+ let ty = table.instantiate_canonical_ns(ty.clone());

+fn iterate_method_candidates_with_autoref<'db>(

+ table: &mut InferenceTable<'db>,

+ receiver_ty: crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,

+ if matches!(receiver_ty.value.kind(), rustc_type_ir::TyKind::Bound(..)) {

+ let interner = table.interner;

+

+ if let rustc_type_ir::TyKind::Ref(_, _, m) = receiver_ty.value.kind() {

+ let m = match m {

+ rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,

+ rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,

+ };

+ let refed = crate::next_solver::Canonical {

+ max_universe: receiver_ty.max_universe,

+ variables: receiver_ty.variables,

+ value: crate::next_solver::Ty::new_ref(interner, crate::next_solver::Region::error(interner), receiver_ty.value, rustc_ast_ir::Mutability::Not),

+ let ref_muted = crate::next_solver::Canonical {

+ max_universe: receiver_ty.max_universe,

+ variables: receiver_ty.variables,

+ value: crate::next_solver::Ty::new_ref(interner, crate::next_solver::Region::error(interner), receiver_ty.value, rustc_ast_ir::Mutability::Mut),

+ if let rustc_type_ir::TyKind::RawPtr(ty, rustc_ast_ir::Mutability::Mut) = receiver_ty.value.kind() {

+ let const_ptr_ty = rustc_type_ir::Canonical {

+ max_universe: rustc_type_ir::UniverseIndex::ZERO,

+ value: crate::next_solver::Ty::new_ptr(interner, ty, rustc_ast_ir::Mutability::Not),

+ variables: receiver_ty.variables,

+fn iterate_method_candidates_by_receiver<'db>(

+ table: &mut InferenceTable<'db>,

+ receiver_ty: crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,

+ let receiver_ty = table.instantiate_canonical_ns(receiver_ty);

+ let receiver_ty: crate::Ty = ChalkToNextSolver::from_nextsolver(receiver_ty, table.interner);

+fn iterate_method_candidates_for_self_ty<'db>(

+ self_ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,

+ db: &'db dyn HirDatabase,

+ let self_ty = ChalkToNextSolver::from_nextsolver(table.instantiate_canonical_ns(self_ty.clone()), table.interner);

+ let canonical_self_ty = ChalkToNextSolver::from_nextsolver(table.canonicalize(self_ty.clone().to_nextsolver(table.interner)), table.interner);

+ let interner = table.interner;

+ let deref_chain = autoderef_method_receiver(&mut table, ty.to_nextsolver(interner));

+ //let goal = generic_implements_goal_ns(db, &table.trait_env, index_trait, &ty);

+ let goal = generic_implements_goal(db, &table.trait_env, index_trait, &ChalkToNextSolver::from_nextsolver(ty, interner));

+ let goal: chalk_ir::Canonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>> = goal.cast(Interner);

+ let goal = goal.to_nextsolver(interner);

+ if !next_trait_solve_canonical(db, table.trait_env.krate, table.trait_env.block, goal).no_solution() {

+ match table.solve_obligation(goal) {

+ Ok(_) => {}

+ Err(_) => {

+ return IsValidCandidate::No;

+/*

+/// This creates Substs for a trait with the given Self type and type variables

+/// for all other parameters, to query the trait solver with it.

+#[tracing::instrument(skip_all)]

+fn generic_implements_goal_ns<'db>(

+ db: &'db dyn HirDatabase,

+ interner: DbInterner<'db>,

+ env: &TraitEnvironment,

+ trait_: TraitId,

+ self_ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,

+) -> crate::next_solver::Canonical<'db, crate::next_solver::Goal<'db, crate::next_solver::Predicate<'db>>> {

+ let variables = self_ty.variables;

+ let trait_ref = TyBuilder::trait_ref(db, trait_)

+ .push(ChalkToNextSolver::from_nextsolver(self_ty.value, interner))

+ .fill_with_bound_vars(DebruijnIndex::INNERMOST, variables.len())

+ .build();

+

+ let infer_ctxt = interner.infer_ctxt().build(TypingMode::non_body_analysis());

+ let args = infer_ctxt.fresh_args_for_item(SolverDefId::TraitId(trait_));

+

+ rustc_type_ir::TraitRef::new(interner, SolverDefId::TraitId(trait_)).with_self_ty(interner, self_ty.value);

+

+

+ let kinds =

+ binders.iter().cloned().chain(trait_ref.substitution.iter(Interner).skip(1).map(|it| {

+ let vk = match it.data(Interner) {

+ GenericArgData::Ty(_) => VariableKind::Ty(chalk_ir::TyVariableKind::General),

+ GenericArgData::Lifetime(_) => VariableKind::Lifetime,

+ GenericArgData::Const(c) => VariableKind::Const(c.data(Interner).ty.clone()),

+ };

+ WithKind::new(vk, UniverseIndex::ROOT)

+ }));

+ let binders = CanonicalVarKinds::from_iter(Interner, kinds);

+

+ let obligation = trait_ref.cast(Interner);

+ let value = InEnvironment::new(&env.env, obligation);

+ crate::next_solver::Canonical { max_universe, value, variables }

+}

+*/

+

+fn autoderef_method_receiver<'db>(

+ table: &mut InferenceTable<'db>,

+ ty: crate::next_solver::Ty<'db>,

+) -> Vec<(crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>, ReceiverAdjustments)> {

+ let interner = table.interner;

+ let mut deref_chain = Vec::new();

+ let mut autoderef = autoderef::Autoderef::new_no_tracking(table, ChalkToNextSolver::from_nextsolver(ty, interner), false, true);

+ autoderef.table.canonicalize(ty.to_nextsolver(interner)),

+ if let Some((rustc_type_ir::Array(parameters, _), variables, max_universe, adj)) =

+ deref_chain.last().map(|d| (d.0.value.kind(), d.0.variables.clone(), d.0.max_universe, d.1.clone()))

+ let unsized_ty = crate::next_solver::Ty::new_slice(interner, parameters);

+ crate::next_solver::Canonical { max_universe, value: unsized_ty, variables, },

+

+use rustc_hash::FxHashMap;

+use rustc_index::Idx;

+use rustc_type_ir::inherent::{Const as _, IntoKind as _, Region as _, SliceLike, Ty as _};

+use rustc_type_ir::InferTy::{self, FloatVar, IntVar, TyVar};

+use rustc_type_ir::{BoundVar, CanonicalQueryInput, CanonicalTyVarKind, DebruijnIndex, Flags, InferConst, RegionKind, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt, UniverseIndex};

+use smallvec::SmallVec;

+use tracing::debug;

+

+use crate::next_solver::infer::InferCtxt;

+use crate::next_solver::{Binder, BoundRegion, BoundRegionKind, BoundTy, Canonical, CanonicalVarKind, CanonicalVars, Const, ConstKind, DbInterner, GenericArg, ParamEnvAnd, Placeholder, Region, Ty, TyKind};

+

+/// When we canonicalize a value to form a query, we wind up replacing

+/// various parts of it with canonical variables. This struct stores

+/// those replaced bits to remember for when we process the query

+/// result.

+#[derive(Clone, Debug)]

+pub struct OriginalQueryValues<'db> {

+ /// Map from the universes that appear in the query to the universes in the

+ /// caller context. For all queries except `evaluate_goal` (used by Chalk),

+ /// we only ever put ROOT values into the query, so this map is very

+ /// simple.

+ pub universe_map: SmallVec<[UniverseIndex; 4]>,

+

+ /// This is equivalent to `CanonicalVarValues`, but using a

+ /// `SmallVec` yields a significant performance win.

+ pub var_values: SmallVec<[GenericArg<'db>; 8]>,

+}

+

+impl<'db> Default for OriginalQueryValues<'db> {

+ fn default() -> Self {

+ let mut universe_map = SmallVec::default();

+ universe_map.push(UniverseIndex::ROOT);

+

+ Self { universe_map, var_values: SmallVec::default() }

+ }

+}

+

+impl<'db> InferCtxt<'db> {

+ /// Canonicalizes a query value `V`. When we canonicalize a query,

+ /// we not only canonicalize unbound inference variables, but we

+ /// *also* replace all free regions whatsoever. So for example a

+ /// query like `T: Trait<'static>` would be canonicalized to

+ ///

+ /// ```text

+ /// T: Trait<'?0>

+ /// ```

+ ///

+ /// with a mapping M that maps `'?0` to `'static`.

+ ///

+ /// To get a good understanding of what is happening here, check

+ /// out the [chapter in the rustc dev guide][c].

+ ///

+ /// [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html#canonicalizing-the-query

+ pub fn canonicalize_query<V>(

+ &self,

+ value: ParamEnvAnd<'db, V>,

+ query_state: &mut OriginalQueryValues<'db>,

+ ) -> CanonicalQueryInput<DbInterner<'db>, ParamEnvAnd<'db, V>>

+ where

+ V: TypeFoldable<DbInterner<'db>>,

+ {

+ let (param_env, value) = value.into_parts();

+ // FIXME(#118965): We don't canonicalize the static lifetimes that appear in the

+ // `param_env` because they are treated differently by trait selection.

+ let canonical_param_env = Canonicalizer::canonicalize(

+ param_env,

+ None,

+ self.interner,

+ &CanonicalizeFreeRegionsOtherThanStatic,

+ query_state,

+ );

+

+ let canonical = Canonicalizer::canonicalize_with_base(

+ canonical_param_env,

+ value,

+ Some(self),

+ self.interner,

+ &CanonicalizeAllFreeRegions,

+ query_state,

+ )

+ .unchecked_map(|(param_env, value)| ParamEnvAnd { param_env, value });

+ CanonicalQueryInput { canonical, typing_mode: self.typing_mode() }

+ }

+

+ /// Canonicalizes a query *response* `V`. When we canonicalize a

+ /// query response, we only canonicalize unbound inference

+ /// variables, and we leave other free regions alone. So,

+ /// continuing with the example from `canonicalize_query`, if

+ /// there was an input query `T: Trait<'static>`, it would have

+ /// been canonicalized to

+ ///

+ /// ```text

+ /// T: Trait<'?0>

+ /// ```

+ ///

+ /// with a mapping M that maps `'?0` to `'static`. But if we found that there

+ /// exists only one possible impl of `Trait`, and it looks like

+ /// ```ignore (illustrative)

+ /// impl<T> Trait<'static> for T { .. }

+ /// ```

+ /// then we would prepare a query result R that (among other

+ /// things) includes a mapping to `'?0 := 'static`. When

+ /// canonicalizing this query result R, we would leave this

+ /// reference to `'static` alone.

+ ///

+ /// To get a good understanding of what is happening here, check

+ /// out the [chapter in the rustc dev guide][c].

+ ///

+ /// [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html#canonicalizing-the-query-result

+ pub fn canonicalize_response<V>(&self, value: V) -> Canonical<'db, V>

+ where

+ V: TypeFoldable<DbInterner<'db>>,

+ {

+ let mut query_state = OriginalQueryValues::default();

+ Canonicalizer::canonicalize(

+ value,

+ Some(self),

+ self.interner,

+ &CanonicalizeQueryResponse,

+ &mut query_state,

+ )

+ }

+

+ pub fn canonicalize_user_type_annotation<V>(&self, value: V) -> Canonical<'db, V>

+ where

+ V: TypeFoldable<DbInterner<'db>>,

+ {

+ let mut query_state = OriginalQueryValues::default();

+ Canonicalizer::canonicalize(

+ value,

+ Some(self),

+ self.interner,

+ &CanonicalizeUserTypeAnnotation,

+ &mut query_state,

+ )

+ }

+}

+

+/// Controls how we canonicalize "free regions" that are not inference

+/// variables. This depends on what we are canonicalizing *for* --

+/// e.g., if we are canonicalizing to create a query, we want to

+/// replace those with inference variables, since we want to make a

+/// maximally general query. But if we are canonicalizing a *query

+/// response*, then we don't typically replace free regions, as they

+/// must have been introduced from other parts of the system.

+trait CanonicalizeMode {

+ fn canonicalize_free_region<'db>(

+ &self,

+ canonicalizer: &mut Canonicalizer<'_, 'db>,

+ r: Region<'db>,

+ ) -> Region<'db>;

+

+ fn any(&self) -> bool;

+

+ // Do we preserve universe of variables.

+ fn preserve_universes(&self) -> bool;

+}

+

+struct CanonicalizeQueryResponse;

+

+impl CanonicalizeMode for CanonicalizeQueryResponse {

+ fn canonicalize_free_region<'db>(

+ &self,

+ canonicalizer: &mut Canonicalizer<'_, 'db>,

+ mut r: Region<'db>,

+ ) -> Region<'db> {

+ let infcx = canonicalizer.infcx.unwrap();

+

+ if let RegionKind::ReVar(vid) = r.kind() {

+ r = infcx

+ .inner

+ .borrow_mut()

+ .unwrap_region_constraints()

+ .opportunistic_resolve_var(canonicalizer.tcx, vid);

+ debug!(

+ "canonical: region var found with vid {vid:?}, \

+ opportunistically resolved to {r:?}",

+ );

+ };

+

+ match r.kind() {

+ RegionKind::ReLateParam(_) | RegionKind::ReErased | RegionKind::ReStatic | RegionKind::ReEarlyParam(..) | RegionKind::ReError(..) => r,

+

+ RegionKind::RePlaceholder(placeholder) => canonicalizer.canonical_var_for_region(

+ CanonicalVarKind::PlaceholderRegion(placeholder),

+ r,

+ ),

+

+ RegionKind::ReVar(vid) => {

+ let universe = infcx

+ .inner

+ .borrow_mut()

+ .unwrap_region_constraints()

+ .probe_value(vid)

+ .unwrap_err();

+ canonicalizer.canonical_var_for_region(

+ CanonicalVarKind::Region(universe),

+ r,

+ )

+ }

+

+ _ => {

+ // Other than `'static` or `'empty`, the query

+ // response should be executing in a fully

+ // canonicalized environment, so there shouldn't be

+ // any other region names it can come up.

+ //

+ // rust-lang/rust#57464: `impl Trait` can leak local

+ // scopes (in manner violating typeck). Therefore, use

+ // `delayed_bug` to allow type error over an ICE.

+ panic!("unexpected region in query response: `{r:?}`");

+ }

+ }

+ }

+

+ fn any(&self) -> bool {

+ false

+ }

+

+ fn preserve_universes(&self) -> bool {

+ true

+ }

+}

+

+struct CanonicalizeUserTypeAnnotation;

+

+impl CanonicalizeMode for CanonicalizeUserTypeAnnotation {

+ fn canonicalize_free_region<'db>(

+ &self,

+ canonicalizer: &mut Canonicalizer<'_, 'db>,

+ r: Region<'db>,

+ ) -> Region<'db> {

+ match r.kind() {

+ RegionKind::ReEarlyParam(_)

+ | RegionKind::ReLateParam(_)

+ | RegionKind::ReErased

+ | RegionKind::ReStatic

+ | RegionKind::ReError(_) => r,

+ RegionKind::ReVar(_) => canonicalizer.canonical_var_for_region_in_root_universe(r),

+ RegionKind::RePlaceholder(..) | RegionKind::ReBound(..) => {

+ // We only expect region names that the user can type.

+ panic!("unexpected region in query response: `{:?}`", r)

+ }

+ }

+ }

+

+ fn any(&self) -> bool {

+ false

+ }

+

+ fn preserve_universes(&self) -> bool {

+ false

+ }

+}

+

+struct CanonicalizeAllFreeRegions;

+

+impl CanonicalizeMode for CanonicalizeAllFreeRegions {

+ fn canonicalize_free_region<'db>(

+ &self,

+ canonicalizer: &mut Canonicalizer<'_, 'db>,

+ r: Region<'db>,

+ ) -> Region<'db> {

+ canonicalizer.canonical_var_for_region_in_root_universe(r)

+ }

+

+ fn any(&self) -> bool {

+ true

+ }

+

+ fn preserve_universes(&self) -> bool {

+ false

+ }

+}

+

+struct CanonicalizeFreeRegionsOtherThanStatic;

+

+impl CanonicalizeMode for CanonicalizeFreeRegionsOtherThanStatic {

+ fn canonicalize_free_region<'db>(

+ &self,

+ canonicalizer: &mut Canonicalizer<'_, 'db>,

+ r: Region<'db>,

+ ) -> Region<'db> {

+ if r.is_static() { r } else { canonicalizer.canonical_var_for_region_in_root_universe(r) }

+ }

+

+ fn any(&self) -> bool {

+ true

+ }

+

+ fn preserve_universes(&self) -> bool {

+ false

+ }

+}

+

+struct Canonicalizer<'cx, 'db> {

+ /// Set to `None` to disable the resolution of inference variables.

+ infcx: Option<&'cx InferCtxt<'db>>,

+ tcx: DbInterner<'db>,

+ variables: SmallVec<[CanonicalVarKind<'db>; 8]>,

+ query_state: &'cx mut OriginalQueryValues<'db>,

+ // Note that indices is only used once `var_values` is big enough to be

+ // heap-allocated.

+ indices: FxHashMap<GenericArg<'db>, BoundVar>,

+ canonicalize_mode: &'cx dyn CanonicalizeMode,

+ needs_canonical_flags: TypeFlags,

+

+ binder_index: DebruijnIndex,

+}

+

+impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {

+ fn cx(&self) -> DbInterner<'db> {

+ self.tcx

+ }

+

+ fn fold_binder<T>(&mut self, t: Binder<'db, T>) -> Binder<'db, T>

+ where

+ T: TypeFoldable<DbInterner<'db>>,

+ {

+ self.binder_index.shift_in(1);

+ let t = t.super_fold_with(self);

+ self.binder_index.shift_out(1);

+ t

+ }

+

+ fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {

+ match r.kind() {

+ RegionKind::ReBound(index, ..) => {

+ if index >= self.binder_index {

+ panic!("escaping late-bound region during canonicalization");

+ } else {

+ r

+ }

+ }

+

+ RegionKind::ReStatic

+ | RegionKind::ReEarlyParam(..)

+ | RegionKind::ReError(_)

+ | RegionKind::ReLateParam(_)

+ | RegionKind::RePlaceholder(..)

+ | RegionKind::ReVar(_)

+ | RegionKind::ReErased => self.canonicalize_mode.canonicalize_free_region(self, r),

+ }

+ }

+

+ fn fold_ty(&mut self, mut t: Ty<'db>) -> Ty<'db> {

+ match t.kind() {

+ TyKind::Infer(TyVar(mut vid)) => {

+ // We need to canonicalize the *root* of our ty var.

+ // This is so that our canonical response correctly reflects

+ // any equated inference vars correctly!

+ let root_vid = self.infcx.unwrap().root_var(vid);

+ if root_vid != vid {

+ t = Ty::new_var(self.tcx, root_vid);

+ vid = root_vid;

+ }

+

+ debug!("canonical: type var found with vid {:?}", vid);

+ match self.infcx.unwrap().probe_ty_var(vid) {

+ // `t` could be a float / int variable; canonicalize that instead.

+ Ok(t) => {

+ debug!("(resolved to {:?})", t);

+ self.fold_ty(t)

+ }

+

+ // `TyVar(vid)` is unresolved, track its universe index in the canonicalized

+ // result.

+ Err(mut ui) => {

+ if !self.canonicalize_mode.preserve_universes() {

+ // FIXME: perf problem described in #55921.

+ ui = UniverseIndex::ROOT;

+ }

+ self.canonicalize_ty_var(

+ CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)),

+ t,

+ )

+ }

+ }

+ }

+

+ TyKind::Infer(IntVar(vid)) => {

+ let nt = self.infcx.unwrap().opportunistic_resolve_int_var(vid);

+ if nt != t {

+ return self.fold_ty(nt);

+ } else {

+ self.canonicalize_ty_var(

+ CanonicalVarKind::Ty(CanonicalTyVarKind::Int),

+ t,

+ )

+ }

+ }

+ TyKind::Infer(FloatVar(vid)) => {

+ let nt = self.infcx.unwrap().opportunistic_resolve_float_var(vid);

+ if nt != t {

+ return self.fold_ty(nt);

+ } else {

+ self.canonicalize_ty_var(

+ CanonicalVarKind::Ty(CanonicalTyVarKind::Float),

+ t,

+ )

+ }

+ }

+

+ TyKind::Infer(InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_)) => {

+ panic!("encountered a fresh type during canonicalization")

+ }

+

+ TyKind::Placeholder(mut placeholder) => {

+ if !self.canonicalize_mode.preserve_universes() {

+ placeholder.universe = UniverseIndex::ROOT;

+ }

+ self.canonicalize_ty_var(

+ CanonicalVarKind::PlaceholderTy(placeholder),

+ t,

+ )

+ }

+

+ TyKind::Bound(debruijn, _) => {

+ if debruijn >= self.binder_index {

+ panic!("escaping bound type during canonicalization")

+ } else {

+ t

+ }

+ }

+

+ TyKind::Closure(..)

+ | TyKind::CoroutineClosure(..)

+ | TyKind::Coroutine(..)

+ | TyKind::CoroutineWitness(..)

+ | TyKind::Bool

+ | TyKind::Char

+ | TyKind::Int(..)

+ | TyKind::Uint(..)

+ | TyKind::Float(..)

+ | TyKind::Adt(..)

+ | TyKind::Str

+ | TyKind::Error(_)

+ | TyKind::Array(..)

+ | TyKind::Slice(..)

+ | TyKind::RawPtr(..)

+ | TyKind::Ref(..)

+ | TyKind::FnDef(..)

+ | TyKind::FnPtr(..)

+ | TyKind::Dynamic(..)

+ | TyKind::UnsafeBinder(_)

+ | TyKind::Never

+ | TyKind::Tuple(..)

+ | TyKind::Alias(..)

+ | TyKind::Foreign(..)

+ | TyKind::Pat(..)

+ | TyKind::Param(..) => {

+ if t.flags().intersects(self.needs_canonical_flags) {

+ t.super_fold_with(self)

+ } else {

+ t

+ }

+ }

+ }

+ }

+

+ fn fold_const(&mut self, mut ct: Const<'db>) -> Const<'db> {

+ match ct.kind() {

+ ConstKind::Infer(InferConst::Var(mut vid)) => {

+ // We need to canonicalize the *root* of our const var.

+ // This is so that our canonical response correctly reflects

+ // any equated inference vars correctly!

+ let root_vid = self.infcx.unwrap().root_const_var(vid);

+ if root_vid != vid {

+ ct = Const::new_var(self.tcx, root_vid);

+ vid = root_vid;

+ }

+

+ debug!("canonical: const var found with vid {:?}", vid);

+ match self.infcx.unwrap().probe_const_var(vid) {

+ Ok(c) => {

+ debug!("(resolved to {:?})", c);

+ return self.fold_const(c);

+ }

+

+ // `ConstVar(vid)` is unresolved, track its universe index in the

+ // canonicalized result

+ Err(mut ui) => {

+ if !self.canonicalize_mode.preserve_universes() {

+ // FIXME: perf problem described in #55921.

+ ui = UniverseIndex::ROOT;

+ }

+ return self.canonicalize_const_var(

+ CanonicalVarKind::Const(ui),

+ ct,

+ );

+ }

+ }

+ }

+ ConstKind::Infer(InferConst::Fresh(_)) => {

+ panic!("encountered a fresh const during canonicalization")

+ }

+ ConstKind::Bound(debruijn, _) => {

+ if debruijn >= self.binder_index {

+ panic!("escaping bound const during canonicalization")

+ } else {

+ return ct;

+ }

+ }

+ ConstKind::Placeholder(placeholder) => {

+ return self.canonicalize_const_var(

+ CanonicalVarKind::PlaceholderConst(placeholder),

+ ct,

+ );

+ }

+ _ => {}

+ }

+

+ if ct.flags().intersects(self.needs_canonical_flags) {

+ ct.super_fold_with(self)

+ } else {

+ ct

+ }

+ }

+}

+

+impl<'cx, 'db> Canonicalizer<'cx, 'db> {

+ /// The main `canonicalize` method, shared impl of

+ /// `canonicalize_query` and `canonicalize_response`.

+ fn canonicalize<V>(

+ value: V,

+ infcx: Option<&InferCtxt<'db>>,

+ tcx: DbInterner<'db>,

+ canonicalize_region_mode: &dyn CanonicalizeMode,

+ query_state: &mut OriginalQueryValues<'db>,

+ ) -> Canonical<'db, V>

+ where

+ V: TypeFoldable<DbInterner<'db>>,

+ {

+ let base = Canonical {

+ max_universe: UniverseIndex::ROOT,

+ variables: CanonicalVars::new_from_iter(tcx, []),

+ value: (),

+ };

+ Canonicalizer::canonicalize_with_base(

+ base,

+ value,

+ infcx,

+ tcx,

+ canonicalize_region_mode,

+ query_state,

+ )

+ .unchecked_map(|((), val)| val)

+ }

+

+ fn canonicalize_with_base<U, V>(

+ base: Canonical<'db, U>,

+ value: V,

+ infcx: Option<&InferCtxt<'db>>,

+ tcx: DbInterner<'db>,

+ canonicalize_region_mode: &dyn CanonicalizeMode,

+ query_state: &mut OriginalQueryValues<'db>,

+ ) -> Canonical<'db, (U, V)>

+ where

+ V: TypeFoldable<DbInterner<'db>>,

+ {

+ let needs_canonical_flags = if canonicalize_region_mode.any() {

+ TypeFlags::HAS_INFER | TypeFlags::HAS_PLACEHOLDER | TypeFlags::HAS_FREE_REGIONS

+ } else {

+ TypeFlags::HAS_INFER | TypeFlags::HAS_PLACEHOLDER

+ };

+

+ // Fast path: nothing that needs to be canonicalized.

+ if !value.has_type_flags(needs_canonical_flags) {

+ return base.unchecked_map(|b| (b, value));

+ }

+

+ let mut canonicalizer = Canonicalizer {

+ infcx,

+ tcx,

+ canonicalize_mode: canonicalize_region_mode,

+ needs_canonical_flags,

+ variables: SmallVec::from_slice(base.variables.as_slice()),

+ query_state,

+ indices: FxHashMap::default(),

+ binder_index: DebruijnIndex::ZERO,

+ };

+ if canonicalizer.query_state.var_values.spilled() {

+ canonicalizer.indices = canonicalizer

+ .query_state

+ .var_values

+ .iter()

+ .enumerate()

+ .map(|(i, &kind)| (kind, BoundVar::from(i)))

+ .collect();

+ }

+ let out_value = value.fold_with(&mut canonicalizer);

+

+ // Once we have canonicalized `out_value`, it should not

+ // contain anything that ties it to this inference context

+ // anymore.

+ debug_assert!(!out_value.has_infer() && !out_value.has_placeholders());

+

+ let canonical_variables = CanonicalVars::new_from_iter(tcx, canonicalizer.universe_canonicalized_variables());

+

+ let max_universe = canonical_variables

+ .iter()

+ .map(|cvar| cvar.universe())

+ .max()

+ .unwrap_or(UniverseIndex::ROOT);

+

+ Canonical { max_universe, variables: canonical_variables, value: (base.value, out_value) }

+ }

+

+ /// Creates a canonical variable replacing `kind` from the input,

+ /// or returns an existing variable if `kind` has already been

+ /// seen. `kind` is expected to be an unbound variable (or

+ /// potentially a free region).

+ fn canonical_var(&mut self, info: CanonicalVarKind<'db>, kind: GenericArg<'db>) -> BoundVar {

+ let Canonicalizer { variables, query_state, indices, .. } = self;

+

+ let var_values = &mut query_state.var_values;

+

+ let universe = info.universe();

+ if universe != UniverseIndex::ROOT {

+ assert!(self.canonicalize_mode.preserve_universes());

+

+ // Insert universe into the universe map. To preserve the order of the

+ // universes in the value being canonicalized, we don't update the

+ // universe in `info` until we have finished canonicalizing.

+ match query_state.universe_map.binary_search(&universe) {

+ Err(idx) => query_state.universe_map.insert(idx, universe),

+ Ok(_) => {}

+ }

+ }

+

+ // This code is hot. `variables` and `var_values` are usually small

+ // (fewer than 8 elements ~95% of the time). They are SmallVec's to

+ // avoid allocations in those cases. We also don't use `indices` to

+ // determine if a kind has been seen before until the limit of 8 has

+ // been exceeded, to also avoid allocations for `indices`.

+ if !var_values.spilled() {

+ // `var_values` is stack-allocated. `indices` isn't used yet. Do a

+ // direct linear search of `var_values`.

+ if let Some(idx) = var_values.iter().position(|&k| k == kind) {

+ // `kind` is already present in `var_values`.

+ BoundVar::new(idx)

+ } else {

+ // `kind` isn't present in `var_values`. Append it. Likewise

+ // for `info` and `variables`.

+ variables.push(info);

+ var_values.push(kind);

+ assert_eq!(variables.len(), var_values.len());

+

+ // If `var_values` has become big enough to be heap-allocated,

+ // fill up `indices` to facilitate subsequent lookups.

+ if var_values.spilled() {

+ assert!(indices.is_empty());

+ *indices = var_values

+ .iter()

+ .enumerate()

+ .map(|(i, &kind)| (kind, BoundVar::new(i)))

+ .collect();

+ }

+ // The cv is the index of the appended element.

+ BoundVar::new(var_values.len() - 1)

+ }

+ } else {

+ // `var_values` is large. Do a hashmap search via `indices`.

+ *indices.entry(kind).or_insert_with(|| {

+ variables.push(info);

+ var_values.push(kind);

+ assert_eq!(variables.len(), var_values.len());

+ BoundVar::new(variables.len() - 1)

+ })

+ }

+ }

+

+ /// Replaces the universe indexes used in `var_values` with their index in

+ /// `query_state.universe_map`. This minimizes the maximum universe used in

+ /// the canonicalized value.

+ fn universe_canonicalized_variables(self) -> SmallVec<[CanonicalVarKind<'db>; 8]> {

+ if self.query_state.universe_map.len() == 1 {

+ return self.variables;

+ }

+

+ let reverse_universe_map: FxHashMap<UniverseIndex, UniverseIndex> = self

+ .query_state

+ .universe_map

+ .iter()

+ .enumerate()

+ .map(|(idx, universe)| (*universe, UniverseIndex::from_usize(idx)))

+ .collect();

+

+ self.variables

+ .iter()

+ .map(|v| match *v {

+ CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => {

+ return *v;

+ }

+ CanonicalVarKind::Ty(CanonicalTyVarKind::General(u)) => {

+ CanonicalVarKind::Ty(CanonicalTyVarKind::General(reverse_universe_map[&u]))

+ }

+ CanonicalVarKind::Region(u) => {

+ CanonicalVarKind::Region(reverse_universe_map[&u])

+ }

+ CanonicalVarKind::Const(u) => CanonicalVarKind::Const(reverse_universe_map[&u]),

+ CanonicalVarKind::PlaceholderTy(placeholder) => {

+ CanonicalVarKind::PlaceholderTy(Placeholder {

+ universe: reverse_universe_map[&placeholder.universe],

+ ..placeholder

+ })

+ }

+ CanonicalVarKind::PlaceholderRegion(placeholder) => {

+ CanonicalVarKind::PlaceholderRegion(Placeholder {

+ universe: reverse_universe_map[&placeholder.universe],

+ ..placeholder

+ })

+ }

+ CanonicalVarKind::PlaceholderConst(placeholder) => {

+ CanonicalVarKind::PlaceholderConst(Placeholder {

+ universe: reverse_universe_map[&placeholder.universe],

+ ..placeholder

+ })

+ }

+ })

+ .collect()

+ }

+

+ /// Shorthand helper that creates a canonical region variable for

+ /// `r` (always in the root universe). The reason that we always

+ /// put these variables into the root universe is because this

+ /// method is used during **query construction:** in that case, we

+ /// are taking all the regions and just putting them into the most

+ /// generic context we can. This may generate solutions that don't

+ /// fit (e.g., that equate some region variable with a placeholder

+ /// it can't name) on the caller side, but that's ok, the caller

+ /// can figure that out. In the meantime, it maximizes our

+ /// caching.

+ ///

+ /// (This works because unification never fails -- and hence trait

+ /// selection is never affected -- due to a universe mismatch.)

+ fn canonical_var_for_region_in_root_universe(

+ &mut self,

+ r: Region<'db>,

+ ) -> Region<'db> {

+ self.canonical_var_for_region(

+ CanonicalVarKind::Region(UniverseIndex::ROOT),

+ r,

+ )

+ }

+

+ /// Creates a canonical variable (with the given `info`)

+ /// representing the region `r`; return a region referencing it.

+ fn canonical_var_for_region(

+ &mut self,

+ info: CanonicalVarKind<'db>,

+ r: Region<'db>,

+ ) -> Region<'db> {

+ let var = self.canonical_var(info, r.into());

+ let br = BoundRegion { var, kind: BoundRegionKind::Anon };

+ Region::new_bound(self.cx(), self.binder_index, br)

+ }

+

+ /// Given a type variable `ty_var` of the given kind, first check

+ /// if `ty_var` is bound to anything; if so, canonicalize

+ /// *that*. Otherwise, create a new canonical variable for

+ /// `ty_var`.

+ fn canonicalize_ty_var(&mut self, info: CanonicalVarKind<'db>, ty_var: Ty<'db>) -> Ty<'db> {

+ debug_assert!(!self.infcx.is_some_and(|infcx| ty_var != infcx.shallow_resolve(ty_var)));

+ let var = self.canonical_var(info, ty_var.into());

+ Ty::new_bound(self.tcx, self.binder_index, BoundTy { kind: crate::next_solver::BoundTyKind::Anon, var })

+ }

+

+ /// Given a type variable `const_var` of the given kind, first check

+ /// if `const_var` is bound to anything; if so, canonicalize

+ /// *that*. Otherwise, create a new canonical variable for

+ /// `const_var`.

+ fn canonicalize_const_var(

+ &mut self,

+ info: CanonicalVarKind<'db>,

+ const_var: Const<'db>,

+ ) -> Const<'db> {

+ debug_assert!(

+ !self.infcx.is_some_and(|infcx| const_var != infcx.shallow_resolve_const(const_var))

+ );

+ let var = self.canonical_var(info, const_var.into());

+ Const::new_bound(self.tcx, self.binder_index, var)

+ }

+}

+pub mod canonicalizer;

+ pub(crate) fn int_unification_table(&mut self) -> UnificationTable<'_, 'db, IntVid> {

+ tracing::debug!(?self.int_unification_storage);

+ pub(crate) fn float_unification_table(&mut self) -> UnificationTable<'_, 'db, FloatVid> {

+#[derive(Clone)]

+ pub fn next_ty_vid(&self) -> TyVid {

+ self.inner.borrow_mut().type_variables().new_var(self.universe(), TypeVariableOrigin { param_def_id: None })

+ }

+

+ pub fn next_const_vid(&self) -> ConstVid {

+ self

+ .inner

+ .borrow_mut()

+ .const_unification_table()

+ .new_key(ConstVariableValue::Unknown { origin: ConstVariableOrigin { param_def_id: None }, universe: self.universe() })

+ .vid

+ }

+

+ pub fn next_int_vid(&self) -> IntVid {

+ self.inner.borrow_mut().int_unification_table().new_key(IntVarValue::Unknown)

+ }

+

+ pub fn next_float_vid(&self) -> FloatVid {

+ self.inner.borrow_mut().float_unification_table().new_key(FloatVarValue::Unknown)

+ }

+

+ pub fn next_region_vid(&self) -> RegionVid {

+ self.inner.borrow_mut().unwrap_region_constraints().new_region_var(self.universe())

+ }

+

+ pub fn resolve_int_var(&self, vid: IntVid) -> Option<Ty<'db>> {

+ let mut inner = self.inner.borrow_mut();

+ let value = inner.int_unification_table().probe_value(vid);

+ match value {

+ IntVarValue::IntType(ty) => Some(Ty::new_int(self.interner, ty)),

+ IntVarValue::UintType(ty) => Some(Ty::new_uint(self.interner, ty)),

+ IntVarValue::Unknown => {

+ None

+ }

+ }

+ }

+

+ pub fn resolve_float_var(&self, vid: FloatVid) -> Option<Ty<'db>> {

+ let mut inner = self.inner.borrow_mut();

+ let value = inner.float_unification_table().probe_value(vid);

+ match value {

+ FloatVarValue::Known(ty) => Some(Ty::new_float(self.interner, ty)),

+ FloatVarValue::Unknown => {

+ None

+ }

+ }

+ }

+

+ pub(crate) fn start_snapshot(&self) -> CombinedSnapshot {

+ pub(crate) fn rollback_to(&self, snapshot: CombinedSnapshot) {

+ CanonicalVarKind, CanonicalVarKinds, FnPointer, InferenceVar, Substitution, TyVariableKind,

+ WellFormed, cast::Cast, fold::Shift, interner::HasInterner,

+ ConstScalar, ImplTraitId, Interner, MemoryMap,

+ from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,

+ fn from_nextsolver(out: Out, interner: DbInterner<'db>) -> Self;

+

+ fn from_nextsolver(out: Ty<'db>, interner: DbInterner<'db>) -> Self {

+ use crate::{Scalar, TyKind};

+ use chalk_ir::{FloatTy, IntTy, UintTy};

+ match out.kind() {

+ rustc_type_ir::TyKind::Bool => TyKind::Scalar(Scalar::Bool),

+ rustc_type_ir::TyKind::Char => TyKind::Scalar(Scalar::Char),

+ rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I8) => {

+ TyKind::Scalar(Scalar::Int(IntTy::I8))

+ }

+ rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I16) => {

+ TyKind::Scalar(Scalar::Int(IntTy::I16))

+ }

+ rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I32) => {

+ TyKind::Scalar(Scalar::Int(IntTy::I32))

+ }

+ rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I64) => {

+ TyKind::Scalar(Scalar::Int(IntTy::I64))

+ }

+ rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I128) => {

+ TyKind::Scalar(Scalar::Int(IntTy::I128))

+ }

+ rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::Isize) => {

+ TyKind::Scalar(Scalar::Int(IntTy::Isize))

+ }

+ rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U8) => {

+ TyKind::Scalar(Scalar::Uint(UintTy::U8))

+ }

+ rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U16) => {

+ TyKind::Scalar(Scalar::Uint(UintTy::U16))

+ }

+ rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U32) => {

+ TyKind::Scalar(Scalar::Uint(UintTy::U32))

+ }

+ rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U64) => {

+ TyKind::Scalar(Scalar::Uint(UintTy::U64))

+ }

+ rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U128) => {

+ TyKind::Scalar(Scalar::Uint(UintTy::U128))

+ }

+ rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::Usize) => {

+ TyKind::Scalar(Scalar::Uint(UintTy::Usize))

+ }

+ rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F16) => {

+ TyKind::Scalar(Scalar::Float(FloatTy::F16))

+ }

+ rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F32) => {

+ TyKind::Scalar(Scalar::Float(FloatTy::F32))

+ }

+ rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F64) => {

+ TyKind::Scalar(Scalar::Float(FloatTy::F64))

+ }

+ rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F128) => {

+ TyKind::Scalar(Scalar::Float(FloatTy::F128))

+ }

+ rustc_type_ir::TyKind::Str => TyKind::Str,

+ rustc_type_ir::TyKind::Error(_) => TyKind::Error,

+ rustc_type_ir::TyKind::Never => TyKind::Never,

+

+ rustc_type_ir::TyKind::Adt(def, args) => {

+ let adt_id = def.inner().id;

+ let subst = ChalkToNextSolver::from_nextsolver(args, interner);

+ TyKind::Adt(chalk_ir::AdtId(adt_id), subst)

+ }

+

+ rustc_type_ir::TyKind::Infer(infer_ty) => {

+ let (var, kind) = match infer_ty {

+ rustc_type_ir::InferTy::TyVar(var) => {

+ (InferenceVar::from(var.as_u32()), TyVariableKind::General)

+ }

+ rustc_type_ir::InferTy::IntVar(var) => {

+ (InferenceVar::from(var.as_u32()), TyVariableKind::Integer)

+ }

+ rustc_type_ir::InferTy::FloatVar(var) => {

+ (InferenceVar::from(var.as_u32()), TyVariableKind::Float)

+ }

+ _ => todo!(),

+ };

+ TyKind::InferenceVar(var, kind)

+ }

+

+ rustc_type_ir::TyKind::Ref(r, ty, mutability) => {

+ let mutability = match mutability {

+ rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,

+ rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,

+ };

+ let r = ChalkToNextSolver::from_nextsolver(r, interner);

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ TyKind::Ref(mutability, r, ty)

+ }

+

+ rustc_type_ir::TyKind::Tuple(tys) => {

+ let size = tys.len();

+ let subst = Substitution::from_iter(

+ Interner,

+ tys.iter().map(|ty| {

+ chalk_ir::GenericArgData::Ty(ChalkToNextSolver::from_nextsolver(

+ ty, interner,

+ ))

+ .intern(Interner)

+ }),

+ );

+ TyKind::Tuple(size, subst)

+ }

+

+ rustc_type_ir::TyKind::Array(ty, const_) => {

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ let const_ = ChalkToNextSolver::from_nextsolver(const_, interner);

+ TyKind::Array(ty, const_)

+ }

+

+ rustc_type_ir::TyKind::Alias(alias_ty_kind, alias_ty) => match alias_ty_kind {

+ rustc_type_ir::AliasTyKind::Projection => {

+ let assoc_ty_id = match alias_ty.def_id {

+ SolverDefId::TypeAliasId(id) => id,

+ _ => unreachable!(),

+ };

+ let associated_ty_id = to_assoc_type_id(assoc_ty_id);

+ let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);

+ TyKind::AssociatedType(associated_ty_id, substitution)

+ }

+ rustc_type_ir::AliasTyKind::Opaque => {

+ let opaque_ty_id = match alias_ty.def_id {

+ SolverDefId::InternedOpaqueTyId(id) => id,

+ _ => unreachable!(),

+ };

+ let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);

+ TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {

+ opaque_ty_id: opaque_ty_id.into(),

+ substitution,

+ }))

+ }

+ rustc_type_ir::AliasTyKind::Inherent => todo!(),

+ rustc_type_ir::AliasTyKind::Free => todo!(),

+ },

+

+ rustc_type_ir::TyKind::Placeholder(placeholder) => {

+ let ui = chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() };

+ let placeholder_index =

+ chalk_ir::PlaceholderIndex { idx: placeholder.bound.var.as_usize(), ui };

+ TyKind::Placeholder(placeholder_index)

+ }

+

+ rustc_type_ir::TyKind::Bound(debruijn_index, ty) => {

+ TyKind::BoundVar(chalk_ir::BoundVar {

+ debruijn: chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),

+ index: ty.var.as_usize(),

+ })

+ }

+

+ rustc_type_ir::TyKind::FnPtr(bound_sig, fn_header) => {

+ let num_binders = bound_sig.bound_vars().len();

+ let sig = chalk_ir::FnSig {

+ abi: fn_header.abi,

+ safety: match fn_header.safety {

+ crate::next_solver::abi::Safety::Safe => chalk_ir::Safety::Safe,

+ crate::next_solver::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,

+ },

+ variadic: fn_header.c_variadic,

+ };

+ let args = GenericArgs::new_from_iter(

+ interner,

+ bound_sig.skip_binder().inputs_and_output.iter().map(|a| a.into()),

+ );

+ let substitution = ChalkToNextSolver::from_nextsolver(args, interner);

+ let substitution = chalk_ir::FnSubst(substitution);

+ let fnptr = chalk_ir::FnPointer { num_binders, sig, substitution };

+ TyKind::Function(fnptr)

+ }

+

+ rustc_type_ir::TyKind::Dynamic(preds, region, dyn_kind) => {

+ assert!(matches!(dyn_kind, rustc_type_ir::DynKind::Dyn));

+ let self_ty = Ty::new_bound(

+ interner,

+ DebruijnIndex::from_u32(1),

+ BoundTy { kind: BoundTyKind::Anon, var: BoundVar::from_u32(0) },

+ );

+ let bounds = chalk_ir::QuantifiedWhereClauses::from_iter(

+ Interner,

+ preds.iter().map(|p| {

+ let binders = chalk_ir::VariableKinds::from_iter(

+ Interner,

+ p.bound_vars().iter().map(|b| match b {

+ BoundVarKind::Ty(kind) => {

+ chalk_ir::VariableKind::Ty(TyVariableKind::General)

+ }

+ BoundVarKind::Region(kind) => chalk_ir::VariableKind::Lifetime,

+ BoundVarKind::Const => chalk_ir::VariableKind::Const(

+ crate::TyKind::Error.intern(Interner),

+ ),

+ }),

+ );

+ let where_clause = match p.skip_binder() {

+ rustc_type_ir::ExistentialPredicate::Trait(trait_ref) => {

+ let trait_ref = TraitRef::new(

+ interner,

+ trait_ref.def_id,

+ [self_ty.clone().into()]

+ .into_iter()

+ .chain(trait_ref.args.iter()),

+ );

+ let trait_id = match trait_ref.def_id {

+ SolverDefId::TraitId(id) => to_chalk_trait_id(id),

+ _ => unreachable!(),

+ };

+ let substitution =

+ ChalkToNextSolver::from_nextsolver(trait_ref.args, interner);

+ let trait_ref = chalk_ir::TraitRef { trait_id, substitution };

+ chalk_ir::WhereClause::Implemented(trait_ref)

+ }

+ rustc_type_ir::ExistentialPredicate::AutoTrait(trait_) => {

+ let trait_id = match trait_ {

+ SolverDefId::TraitId(id) => to_chalk_trait_id(id),

+ _ => unreachable!(),

+ };

+ let substitution = chalk_ir::Substitution::empty(Interner);

+ let trait_ref = chalk_ir::TraitRef { trait_id, substitution };

+ chalk_ir::WhereClause::Implemented(trait_ref)

+ }

+ rustc_type_ir::ExistentialPredicate::Projection(

+ existential_projection,

+ ) => {

+ let projection = ProjectionPredicate {

+ projection_term: AliasTerm::new(

+ interner,

+ existential_projection.def_id,

+ [self_ty.clone().into()]

+ .iter()

+ .chain(existential_projection.args.clone().iter()),

+ ),

+ term: existential_projection.term.clone(),

+ };

+ let associated_ty_id = match projection.projection_term.def_id {

+ SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),

+ _ => unreachable!(),

+ };

+ let substitution = ChalkToNextSolver::from_nextsolver(

+ projection.projection_term.args,

+ interner,

+ );

+ let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {

+ associated_ty_id,

+ substitution,

+ });

+ let ty = match projection.term {

+ Term::Ty(ty) => ty,

+ _ => unreachable!(),

+ };

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ let alias_eq = chalk_ir::AliasEq { alias, ty };

+ chalk_ir::WhereClause::AliasEq(alias_eq)

+ }

+ };

+ chalk_ir::Binders::new(binders, where_clause)

+ }),

+ );

+ let binders = chalk_ir::VariableKinds::from1(

+ Interner,

+ chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),

+ );

+ let bounds = chalk_ir::Binders::new(binders, bounds);

+ let dyn_ty = chalk_ir::DynTy {

+ bounds,

+ lifetime: ChalkToNextSolver::from_nextsolver(region, interner),

+ };

+ TyKind::Dyn(dyn_ty)

+ }

+

+ rustc_type_ir::TyKind::Slice(ty) => {

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ TyKind::Slice(ty)

+ }

+

+ rustc_type_ir::TyKind::Foreign(def_id) => {

+ let id = match def_id {

+ SolverDefId::TypeAliasId(id) => to_foreign_def_id(id),

+ _ => unreachable!(),

+ };

+ TyKind::Foreign(id)

+ }

+ rustc_type_ir::TyKind::Pat(_, _) => todo!(),

+ rustc_type_ir::TyKind::RawPtr(ty, mutability) => {

+ let mutability = match mutability {

+ rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,

+ rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,

+ };

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ TyKind::Raw(mutability, ty)

+ }

+ rustc_type_ir::TyKind::FnDef(def_id, args) => {

+ let subst = ChalkToNextSolver::from_nextsolver(args, interner);

+ match def_id {

+ SolverDefId::FunctionId(id) => {

+ TyKind::FnDef(CallableDefId::FunctionId(id).to_chalk(interner.db()), subst)

+ }

+ SolverDefId::Ctor(Ctor::Enum(e)) => TyKind::FnDef(

+ CallableDefId::EnumVariantId(e).to_chalk(interner.db()),

+ subst,

+ ),

+ SolverDefId::Ctor(Ctor::Struct(s)) => {

+ TyKind::FnDef(CallableDefId::StructId(s).to_chalk(interner.db()), subst)

+ }

+ _ => unreachable!("Unexpected def id {:?}", def_id),

+ }

+ }

+

+ rustc_type_ir::TyKind::Closure(def_id, args) => {

+ let id = match def_id {

+ SolverDefId::InternedClosureId(id) => id,

+ _ => unreachable!(),

+ };

+ let subst = ChalkToNextSolver::from_nextsolver(args, interner);

+ TyKind::Closure(id.into(), subst)

+ }

+ rustc_type_ir::TyKind::CoroutineClosure(_, _) => todo!(),

+ rustc_type_ir::TyKind::Coroutine(def_id, args) => {

+ let id = match def_id {

+ SolverDefId::InternedCoroutineId(id) => id,

+ _ => unreachable!(),

+ };

+ let subst = ChalkToNextSolver::from_nextsolver(args, interner);

+ TyKind::Coroutine(id.into(), subst)

+ }

+ rustc_type_ir::TyKind::CoroutineWitness(def_id, args) => {

+ let id = match def_id {

+ SolverDefId::InternedCoroutineId(id) => id,

+ _ => unreachable!(),

+ };

+ let subst = ChalkToNextSolver::from_nextsolver(args, interner);

+ TyKind::CoroutineWitness(id.into(), subst)

+ }

+

+ rustc_type_ir::TyKind::Param(_) => todo!(),

+ rustc_type_ir::TyKind::UnsafeBinder(_) => todo!(),

+ }

+ .intern(Interner)

+ }

+

+ fn from_nextsolver(out: Region<'db>, interner: DbInterner<'db>) -> Self {

+ match out.kind() {

+ rustc_type_ir::RegionKind::ReEarlyParam(early) => todo!(),

+ rustc_type_ir::RegionKind::ReBound(db, bound) => chalk_ir::Lifetime::new(

+ Interner,

+ chalk_ir::LifetimeData::BoundVar(chalk_ir::BoundVar::new(

+ chalk_ir::DebruijnIndex::new(db.as_u32()),

+ bound.var.as_usize(),

+ )),

+ ),

+ rustc_type_ir::RegionKind::ReLateParam(_) => todo!(),

+ rustc_type_ir::RegionKind::ReStatic => {

+ chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Static)

+ }

+ rustc_type_ir::RegionKind::ReVar(vid) => chalk_ir::Lifetime::new(

+ Interner,

+ chalk_ir::LifetimeData::InferenceVar(chalk_ir::InferenceVar::from(vid.as_u32())),

+ ),

+ rustc_type_ir::RegionKind::RePlaceholder(placeholder) => chalk_ir::Lifetime::new(

+ Interner,

+ chalk_ir::LifetimeData::Placeholder(chalk_ir::PlaceholderIndex {

+ idx: placeholder.bound.var.as_usize(),

+ ui: chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() },

+ }),

+ ),

+ rustc_type_ir::RegionKind::ReErased => {

+ chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Erased)

+ }

+ rustc_type_ir::RegionKind::ReError(_) => {

+ chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Error)

+ }

+ }

+ }

+

+ fn from_nextsolver(out: Const<'db>, interner: DbInterner<'db>) -> Self {

+ let value: chalk_ir::ConstValue<Interner> = match out.kind() {

+ rustc_type_ir::ConstKind::Param(_) => unimplemented!(),

+ rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var(var)) => {

+ chalk_ir::ConstValue::InferenceVar(chalk_ir::InferenceVar::from(var.as_u32()))

+ }

+ rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Fresh(fresh)) => {

+ panic!("Vars should not be freshened.")

+ }

+ rustc_type_ir::ConstKind::Bound(debruijn_index, var) => {

+ chalk_ir::ConstValue::BoundVar(chalk_ir::BoundVar::new(

+ chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),

+ var.index(),

+ ))

+ }

+ rustc_type_ir::ConstKind::Placeholder(placeholder_const) => {

+ chalk_ir::ConstValue::Placeholder(chalk_ir::PlaceholderIndex {

+ ui: chalk_ir::UniverseIndex { counter: placeholder_const.universe.as_usize() },

+ idx: placeholder_const.bound.as_usize(),

+ })

+ }

+ rustc_type_ir::ConstKind::Unevaluated(unevaluated_const) => {

+ let id = match unevaluated_const.def {

+ SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),

+ SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),

+ _ => unreachable!(),

+ };

+ let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);

+ chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {

+ interned: ConstScalar::UnevaluatedConst(id, subst),

+ })

+ }

+ rustc_type_ir::ConstKind::Value(value_const) => {

+ let bytes = value_const.value.inner();

+ let value = chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {

+ // SAFETY: will never use this without a db

+ interned: ConstScalar::Bytes(bytes.0.clone(), unsafe {

+ std::mem::transmute::<MemoryMap<'_>, MemoryMap<'static>>(bytes.1.clone())

+ }),

+ });

+ return chalk_ir::ConstData {

+ ty: ChalkToNextSolver::from_nextsolver(value_const.ty, interner),

+ value,

+ }

+ .intern(Interner);

+ }

+ rustc_type_ir::ConstKind::Error(_) => {

+ chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {

+ interned: ConstScalar::Unknown,

+ })

+ }

+ rustc_type_ir::ConstKind::Expr(_) => unimplemented!(),

+ };

+ chalk_ir::ConstData { ty: crate::TyKind::Error.intern(Interner), value }.intern(Interner)

+ }

+

+ fn from_nextsolver(

+ out: rustc_type_ir::FnSigTys<DbInterner<'db>>,

+ interner: DbInterner<'db>,

+ ) -> Self {

+ todo!()

+ }

+

+ fn from_nextsolver(

+ out: rustc_type_ir::Binder<DbInterner<'db>, U>,

+ interner: DbInterner<'db>,

+ ) -> Self {

+ todo!()

+ }

+

+ fn from_nextsolver(out: BoundVarKinds, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+

+ fn from_nextsolver(out: BoundVarKind, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+

+ fn from_nextsolver(out: GenericArg<'db>, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+

+ fn from_nextsolver(out: GenericArgs<'db>, interner: DbInterner<'db>) -> Self {

+ let mut substs = Vec::with_capacity(out.len());

+ for arg in out.iter() {

+ match arg.clone().kind() {

+ rustc_type_ir::GenericArgKind::Type(ty) => {

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ substs.push(chalk_ir::GenericArgData::Ty(ty).intern(Interner));

+ }

+ rustc_type_ir::GenericArgKind::Lifetime(region) => {

+ let lifetime = ChalkToNextSolver::from_nextsolver(region, interner);

+ substs.push(chalk_ir::GenericArgData::Lifetime(lifetime).intern(Interner));

+ }

+ rustc_type_ir::GenericArgKind::Const(const_) => {

+ substs.push(

+ chalk_ir::GenericArgData::Const(ChalkToNextSolver::from_nextsolver(

+ const_, interner,

+ ))

+ .intern(Interner),

+ );

+ }

+ }

+ }

+ Substitution::from_iter(Interner, substs)

+ }

+

+ fn from_nextsolver(out: Tys<'db>, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+

+ fn from_nextsolver(out: rustc_type_ir::DebruijnIndex, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+

+ fn from_nextsolver(out: rustc_type_ir::UniverseIndex, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+

+ fn from_nextsolver(out: rustc_type_ir::InferTy, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+

+ fn from_nextsolver(out: rustc_ast_ir::Mutability, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+

+ fn from_nextsolver(out: rustc_type_ir::Variance, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+impl<'db> ChalkToNextSolver<'db, rustc_type_ir::Variance> for chalk_ir::Variance {

+ fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::Variance {

+ match self {

+ chalk_ir::Variance::Covariant => rustc_type_ir::Variance::Covariant,

+ chalk_ir::Variance::Invariant => rustc_type_ir::Variance::Invariant,

+ chalk_ir::Variance::Contravariant => rustc_type_ir::Variance::Contravariant,

+ }

+ }

+

+ fn from_nextsolver(out: rustc_type_ir::Variance, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+}

+

+impl<'db> ChalkToNextSolver<'db, VariancesOf> for chalk_ir::Variances<Interner> {

+ fn to_nextsolver(&self, interner: DbInterner<'db>) -> VariancesOf {

+ VariancesOf::new_from_iter(

+ interner,

+ self.as_slice(Interner).iter().map(|v| v.to_nextsolver(interner)),

+ )

+ }

+

+ fn from_nextsolver(out: VariancesOf, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+}

+

+impl<'db> ChalkToNextSolver<'db, Goal<DbInterner<'db>, Predicate<'db>>>

+ for chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>

+ fn to_nextsolver(&self, interner: DbInterner<'db>) -> Goal<DbInterner<'db>, Predicate<'db>> {

+ Goal::new(

+ interner,

+ self.environment.to_nextsolver(interner),

+ self.goal.to_nextsolver(interner),

+ )

+ }

+

+ fn from_nextsolver(

+ out: Goal<DbInterner<'db>, Predicate<'db>>,

+ ) -> Self {

+ chalk_ir::InEnvironment {

+ environment: ChalkToNextSolver::from_nextsolver(out.param_env, interner),

+ goal: ChalkToNextSolver::from_nextsolver(out.predicate, interner),

+ }

+ }

+}

+

+impl<'db, T: HasInterner<Interner = Interner> + ChalkToNextSolver<'db, U>, U>

+ ChalkToNextSolver<'db, Canonical<'db, U>> for chalk_ir::Canonical<T>

+{

+ fn to_nextsolver(&self, interner: DbInterner<'db>) -> Canonical<'db, U> {

+ value: self.value.to_nextsolver(interner),

+

+ fn from_nextsolver(out: Canonical<'db, U>, interner: DbInterner<'db>) -> Self {

+ let binders = chalk_ir::CanonicalVarKinds::from_iter(

+ Interner,

+ out.variables.iter().map(|v| match v {

+ rustc_type_ir::CanonicalVarKind::Ty(

+ rustc_type_ir::CanonicalTyVarKind::General(ui),

+ ) => chalk_ir::CanonicalVarKind::new(

+ chalk_ir::VariableKind::Ty(TyVariableKind::General),

+ chalk_ir::UniverseIndex { counter: ui.as_usize() },

+ ),

+ rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Int) => {

+ chalk_ir::CanonicalVarKind::new(

+ chalk_ir::VariableKind::Ty(TyVariableKind::Integer),

+ chalk_ir::UniverseIndex::root(),

+ )

+ }

+ rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Float) => {

+ chalk_ir::CanonicalVarKind::new(

+ chalk_ir::VariableKind::Ty(TyVariableKind::Float),

+ chalk_ir::UniverseIndex::root(),

+ )

+ }

+ rustc_type_ir::CanonicalVarKind::PlaceholderTy(_) => todo!(),

+ rustc_type_ir::CanonicalVarKind::Region(ui) => chalk_ir::CanonicalVarKind::new(

+ chalk_ir::VariableKind::Lifetime,

+ chalk_ir::UniverseIndex { counter: ui.as_usize() },

+ ),

+ rustc_type_ir::CanonicalVarKind::PlaceholderRegion(_) => todo!(),

+ rustc_type_ir::CanonicalVarKind::Const(ui) => chalk_ir::CanonicalVarKind::new(

+ chalk_ir::VariableKind::Const(chalk_ir::TyKind::Error.intern(Interner)),

+ chalk_ir::UniverseIndex { counter: ui.as_usize() },

+ ),

+ rustc_type_ir::CanonicalVarKind::PlaceholderConst(_) => todo!(),

+ }),

+ );

+ let value = ChalkToNextSolver::from_nextsolver(out.value, interner);

+ chalk_ir::Canonical { binders, value }

+ }

+ chalk_ir::GoalData::EqGoal(eq_goal) => {

+ let pred_kind = PredicateKind::AliasRelate(

+ Term::Ty(eq_goal.a.assert_ty_ref(Interner).clone().to_nextsolver(interner)),

+ Term::Ty(eq_goal.b.assert_ty_ref(Interner).clone().to_nextsolver(interner)),

+ rustc_type_ir::AliasRelationDirection::Equate,

+ );

+ let pred_kind =

+ Binder::bind_with_vars(pred_kind, BoundVarKinds::new_from_iter(interner, []));

+ Predicate::new(interner, pred_kind)

+ }

+

+ fn from_nextsolver(out: Predicate<'db>, interner: DbInterner<'db>) -> Self {

+ chalk_ir::Goal::new(

+ Interner,

+ match out.kind().skip_binder() {

+ rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Trait(

+ trait_pred,

+ )) => {

+ let trait_ref =

+ ChalkToNextSolver::from_nextsolver(trait_pred.trait_ref, interner);

+ let where_clause = chalk_ir::WhereClause::Implemented(trait_ref);

+ chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))

+ }

+ rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Projection(

+ proj_predicate,

+ )) => {

+ let associated_ty_id = match proj_predicate.def_id() {

+ SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),

+ _ => unreachable!(),

+ };

+ let substitution = ChalkToNextSolver::from_nextsolver(

+ proj_predicate.projection_term.args,

+ interner,

+ );

+ let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {

+ associated_ty_id,

+ substitution,

+ });

+ let ty = match proj_predicate.term.kind() {

+ rustc_type_ir::TermKind::Ty(ty) => ty,

+ rustc_type_ir::TermKind::Const(_) => todo!(),

+ };

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ let alias_eq = chalk_ir::AliasEq { alias, ty };

+ let where_clause = chalk_ir::WhereClause::AliasEq(alias_eq);

+ chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))

+ }

+ rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::TypeOutlives(

+ outlives,

+ )) => {

+ let lifetime = ChalkToNextSolver::from_nextsolver(outlives.1, interner);

+ let ty = ChalkToNextSolver::from_nextsolver(outlives.0, interner);

+ let where_clause =

+ chalk_ir::WhereClause::TypeOutlives(chalk_ir::TypeOutlives {

+ lifetime,

+ ty,

+ });

+ chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))

+ }

+ rustc_type_ir::PredicateKind::Clause(

+ rustc_type_ir::ClauseKind::RegionOutlives(outlives),

+ ) => {

+ let a = ChalkToNextSolver::from_nextsolver(outlives.0, interner);

+ let b = ChalkToNextSolver::from_nextsolver(outlives.1, interner);

+ let where_clause =

+ chalk_ir::WhereClause::LifetimeOutlives(chalk_ir::LifetimeOutlives {

+ a,

+ b,

+ });

+ chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))

+ }

+ rustc_type_ir::PredicateKind::Clause(_) => todo!(),

+ rustc_type_ir::PredicateKind::DynCompatible(_) => todo!(),

+ rustc_type_ir::PredicateKind::Subtype(subtype_predicate) => todo!(),

+ rustc_type_ir::PredicateKind::Coerce(coerce_predicate) => todo!(),

+ rustc_type_ir::PredicateKind::ConstEquate(_, _) => todo!(),

+ rustc_type_ir::PredicateKind::Ambiguous => todo!(),

+ rustc_type_ir::PredicateKind::NormalizesTo(normalizes_to) => todo!(),

+ rustc_type_ir::PredicateKind::AliasRelate(

+ alias_term,

+ ty_term,

+ alias_relation_direction,

+ ) => {

+ let ty = match ty_term {

+ Term::Ty(ty) => ChalkToNextSolver::from_nextsolver(ty, interner),

+ Term::Const(..) => todo!(),

+ };

+ match alias_term {

+ Term::Ty(alias_ty) => match alias_ty.kind() {

+ rustc_type_ir::TyKind::Alias(kind, alias) => match kind {

+ rustc_type_ir::AliasTyKind::Projection => {

+ let associated_ty_id = match alias.def_id {

+ SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),

+ _ => todo!(),

+ };

+ let substitution =

+ ChalkToNextSolver::from_nextsolver(alias.args, interner);

+ let proj_ty =

+ chalk_ir::ProjectionTy { associated_ty_id, substitution };

+ let alias = chalk_ir::AliasTy::Projection(proj_ty);

+ let alias_eq = chalk_ir::AliasEq { alias, ty };

+ chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(

+ chalk_ir::WhereClause::AliasEq(alias_eq),

+ ))

+ }

+ _ => todo!(),

+ },

+ rustc_type_ir::TyKind::Infer(var) => {

+ assert!(matches!(

+ alias_relation_direction,

+ rustc_type_ir::AliasRelationDirection::Equate

+ ));

+ let a: chalk_ir::Ty<_> =

+ ChalkToNextSolver::from_nextsolver(alias_ty, interner);

+ let eq_goal = chalk_ir::EqGoal {

+ a: chalk_ir::GenericArgData::Ty(a).intern(Interner),

+ b: chalk_ir::GenericArgData::Ty(ty).intern(Interner),

+ };

+ chalk_ir::GoalData::EqGoal(eq_goal)

+ }

+ _ => todo!("Unexpected alias term {:?}", alias_term),

+ },

+ Term::Const(..) => todo!(),

+ }

+ }

+ },

+ )

+ }

+

+ fn from_nextsolver(out: ParamEnv<'db>, interner: DbInterner<'db>) -> Self {

+ let clauses = chalk_ir::ProgramClauses::from_iter(

+ Interner,

+ out.clauses.iter().map(|c| -> chalk_ir::ProgramClause<Interner> {

+ ChalkToNextSolver::from_nextsolver(c, interner)

+ }),

+ );

+ chalk_ir::Environment { clauses }

+ }

+

+ fn from_nextsolver(out: Clause<'db>, interner: DbInterner<'db>) -> Self {

+ chalk_ir::ProgramClause::new(

+ Interner,

+ chalk_ir::ProgramClauseData(chalk_ir::Binders::empty(

+ Interner,

+ ChalkToNextSolver::from_nextsolver(out.0.kind().skip_binder(), interner),

+ )),

+ )

+ }

+ fn from_nextsolver(out: PredicateKind<'db>, interner: DbInterner<'db>) -> Self {

+ chalk_ir::ProgramClauseImplication {

+ consequence: ChalkToNextSolver::from_nextsolver(out, interner),

+ conditions: chalk_ir::Goals::empty(Interner),

+ constraints: chalk_ir::Constraints::empty(Interner),

+ priority: chalk_ir::ClausePriority::High,

+ }

+ }

+

+ fn from_nextsolver(out: PredicateKind<'db>, interner: DbInterner<'db>) -> Self {

+ let domain_goal = match out {

+ rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Trait(trait_pred)) => {

+ let trait_ref = ChalkToNextSolver::from_nextsolver(trait_pred.trait_ref, interner);

+ let where_clause = chalk_ir::WhereClause::Implemented(trait_ref);

+ chalk_ir::DomainGoal::Holds(where_clause)

+ }

+ rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Projection(

+ proj_predicate,

+ )) => {

+ let associated_ty_id = match proj_predicate.def_id() {

+ SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),

+ _ => unreachable!(),

+ };

+ let substitution = ChalkToNextSolver::from_nextsolver(

+ proj_predicate.projection_term.args,

+ interner,

+ );

+ let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {

+ associated_ty_id,

+ substitution,

+ });

+ let ty = match proj_predicate.term.kind() {

+ rustc_type_ir::TermKind::Ty(ty) => ty,

+ rustc_type_ir::TermKind::Const(_) => todo!(),

+ };

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ let alias_eq = chalk_ir::AliasEq { alias, ty };

+ let where_clause = chalk_ir::WhereClause::AliasEq(alias_eq);

+ chalk_ir::DomainGoal::Holds(where_clause)

+ }

+ rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::TypeOutlives(

+ outlives,

+ )) => {

+ let lifetime = ChalkToNextSolver::from_nextsolver(outlives.1, interner);

+ let ty = ChalkToNextSolver::from_nextsolver(outlives.0, interner);

+ let where_clause =

+ chalk_ir::WhereClause::TypeOutlives(chalk_ir::TypeOutlives { lifetime, ty });

+ chalk_ir::DomainGoal::Holds(where_clause)

+ }

+ rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::RegionOutlives(

+ outlives,

+ )) => {

+ let a = ChalkToNextSolver::from_nextsolver(outlives.0, interner);

+ let b = ChalkToNextSolver::from_nextsolver(outlives.1, interner);

+ let where_clause =

+ chalk_ir::WhereClause::LifetimeOutlives(chalk_ir::LifetimeOutlives { a, b });

+ chalk_ir::DomainGoal::Holds(where_clause)

+ }

+ rustc_type_ir::PredicateKind::Clause(_) => todo!(),

+ rustc_type_ir::PredicateKind::DynCompatible(_) => todo!(),

+ rustc_type_ir::PredicateKind::Subtype(subtype_predicate) => todo!(),

+ rustc_type_ir::PredicateKind::Coerce(coerce_predicate) => todo!(),

+ rustc_type_ir::PredicateKind::ConstEquate(_, _) => todo!(),

+ rustc_type_ir::PredicateKind::Ambiguous => todo!(),

+ rustc_type_ir::PredicateKind::NormalizesTo(normalizes_to) => todo!(),

+ rustc_type_ir::PredicateKind::AliasRelate(

+ alias_term,

+ ty_term,

+ alias_relation_direction,

+ ) => {

+ let alias = match alias_term {

+ Term::Ty(alias_ty) => match alias_ty.kind() {

+ rustc_type_ir::TyKind::Alias(kind, alias) => match kind {

+ rustc_type_ir::AliasTyKind::Projection => {

+ let associated_ty_id = match alias.def_id {

+ SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),

+ _ => todo!(),

+ };

+ let substitution =

+ ChalkToNextSolver::from_nextsolver(alias.args, interner);

+ let proj_ty =

+ chalk_ir::ProjectionTy { associated_ty_id, substitution };

+ chalk_ir::AliasTy::Projection(proj_ty)

+ }

+ _ => todo!(),

+ },

+ _ => todo!(),

+ },

+ Term::Const(..) => todo!(),

+ };

+ let ty = match ty_term {

+ Term::Ty(ty) => ChalkToNextSolver::from_nextsolver(ty, interner),

+ Term::Const(..) => todo!(),

+ };

+ let alias_eq = chalk_ir::AliasEq { alias, ty };

+ chalk_ir::DomainGoal::Holds(chalk_ir::WhereClause::AliasEq(alias_eq))

+ }

+ };

+ domain_goal

+ }

+

+ fn from_nextsolver(out: TraitRef<'db>, interner: DbInterner<'db>) -> Self {

+ let trait_id = match out.def_id {

+ SolverDefId::TraitId(id) => to_chalk_trait_id(id),

+ _ => unreachable!(),

+ };

+ let substitution = ChalkToNextSolver::from_nextsolver(out.args, interner);

+ chalk_ir::TraitRef { trait_id, substitution }

+ }

+

+ fn from_nextsolver(out: PredicateKind<'db>, interner: DbInterner<'db>) -> Self {

+ todo!()

+ }

+ subst: ChalkToNextSolver::from_nextsolver(

+ GenericArgs::new_from_iter(interner, value),

+ interner,

+ ),

+ let subst = ChalkToNextSolver::from_nextsolver(args, interner);

+ _ => todo!(),

+ chalk_ir::GenericArgData::Ty(ChalkToNextSolver::from_nextsolver(ty, interner))

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ let const_ = ChalkToNextSolver::from_nextsolver(const_, interner);

+ let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);

+ let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);

+ rustc_type_ir::AliasTyKind::Inherent => todo!(),

+ rustc_type_ir::AliasTyKind::Free => todo!(),

+ let substitution = ChalkToNextSolver::from_nextsolver(args, interner);

+ [self_ty.clone().into()].into_iter().chain(trait_ref.args.iter()),

+ ChalkToNextSolver::from_nextsolver(trait_ref.args, interner);

+ [self_ty.clone().into()]

+ .chain(existential_projection.args.clone().iter()),

+ term: existential_projection.term.clone(),

+ let substitution = ChalkToNextSolver::from_nextsolver(

+ projection.projection_term.args,

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ rustc_type_ir::TyKind::Pat(_, _) => todo!(),

+ let ty = ChalkToNextSolver::from_nextsolver(ty, interner);

+ let subst = ChalkToNextSolver::from_nextsolver(args, interner);

+ match def_id {

+ SolverDefId::FunctionId(id) => {

+ TyKind::FnDef(CallableDefId::FunctionId(id).to_chalk(interner.db()), subst)

+ }

+ SolverDefId::Ctor(Ctor::Enum(e)) => {

+ TyKind::FnDef(CallableDefId::EnumVariantId(e).to_chalk(interner.db()), subst)

+ }

+ SolverDefId::Ctor(Ctor::Struct(s)) => {

+ TyKind::FnDef(CallableDefId::StructId(s).to_chalk(interner.db()), subst)

+ }

+ _ => unreachable!("Unexpected def id {:?}", def_id),

+ }

+ let subst = ChalkToNextSolver::from_nextsolver(args, interner);

+ rustc_type_ir::TyKind::CoroutineClosure(_, _) => todo!(),

+ let subst = ChalkToNextSolver::from_nextsolver(args, interner);

+ let subst = ChalkToNextSolver::from_nextsolver(args, interner);

+

+pub trait InferenceVarExt {

+ fn to_vid(self) -> rustc_type_ir::TyVid;

+ fn from_vid(vid: rustc_type_ir::TyVid) -> InferenceVar;

+}

+

+impl InferenceVarExt for InferenceVar {

+ fn to_vid(self) -> rustc_type_ir::TyVid {

+ rustc_type_ir::TyVid::from_u32(self.index())

+ }

+ fn from_vid(vid: rustc_type_ir::TyVid) -> InferenceVar {

+ InferenceVar::from(vid.as_u32())

+ }

+}

+ mapping::ChalkToNextSolver,

+ let subst = ChalkToNextSolver::from_nextsolver(uv.args, self.interner);

+use std::hash::Hash;

+ db::HirDatabase, infer::unify::InferenceTable, next_solver::{

+ infer::{DbInternerInferExt, InferCtxt}, mapping::{convert_canonical_args_for_result, ChalkToNextSolver}, util::mini_canonicalize, DbInterner, GenericArg, Predicate, SolverContext, Span

+ }, utils::UnevaluatedConstEvaluatorFolder, AliasEq, AliasTy, Canonical, DomainGoal, Goal, InEnvironment, Interner, ProjectionTy, ProjectionTyExt, TraitRefExt, Ty, TyKind, TypeFlags, WhereClause

+pub fn next_trait_solve_canonical<'db>(

+ db: &'db dyn HirDatabase,

+ krate: Crate,

+ block: Option<BlockId>,

+ goal: crate::next_solver::Canonical<'db, crate::next_solver::Goal<'db, Predicate<'db>>>,

+) -> NextTraitSolveResult {

+ // FIXME: should use analysis_in_body, but that needs GenericDefId::Block

+ let context = SolverContext(

+ DbInterner::new_with(db, Some(krate), block)

+ .infer_ctxt()

+ .build(TypingMode::non_body_analysis()),

+ );

+

+ tracing::info!(?goal);

+

+ let (goal, var_values) =

+ context.instantiate_canonical(&goal);

+ tracing::info!(?var_values);

+

+ let res = context.evaluate_root_goal(

+ goal.clone(),

+ Span::dummy(),

+ None

+ );

+

+ let vars =

+ var_values.var_values.iter().map(|g| context.0.resolve_vars_if_possible(g)).collect();

+ let canonical_var_values = mini_canonicalize(context, vars);

+

+ let res = res.map(|r| (r.has_changed, r.certainty, canonical_var_values));

+

+ tracing::debug!("solve_nextsolver({:?}) => {:?}", goal, res);

+

+ match res {

+ Err(_) => NextTraitSolveResult::NoSolution,

+ Ok((_, Certainty::Yes, args)) => NextTraitSolveResult::Certain(

+ convert_canonical_args_for_result(DbInterner::new_with(db, Some(krate), block), args)

+ ),

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

+ let subst = convert_canonical_args_for_result(

+ DbInterner::new_with(db, Some(krate), block),

+ args,

+ );

+ NextTraitSolveResult::Uncertain(chalk_ir::Canonical {

+ binders: subst.binders,

+ value: subst.value.subst,

+ })

+ }

+ }

+}

+

+use hir_ty::{db::HirDatabase, method_resolution, next_solver::{mapping::ChalkToNextSolver, DbInterner}};

+ &canonical.to_nextsolver(DbInterner::new_with(db, Some(environment.krate), environment.block)),

+ &canonical.to_nextsolver(DbInterner::new_with(

+ db,

+ Some(environment.krate),

+ environment.block,

+ )),

+ &canonical.to_nextsolver(DbInterner::new_with(

+ db,

+ Some(environment.krate),

+ environment.block,

+ )),