WIP switch inference table to next-solver

Author: jackh726

src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs

@@ -27,7 +27,7 @@ use crate::{
     next_solver::{
         Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs,
         ParamConst, SolverDefId, Ty, ValueConst,
-        mapping::{ChalkToNextSolver, convert_args_for_result, convert_binder_to_early_binder},
+        mapping::{ChalkToNextSolver, convert_binder_to_early_binder},
     },
 };
 
@@ -145,7 +145,7 @@ pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: Const<'db>) -> Option<u
                 SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
                 _ => unreachable!(),
             };
-            let subst = convert_args_for_result(interner, unevaluated_const.args.as_slice());
+            let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);
             let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);
             try_const_usize(db, ec)
         }
@@ -168,7 +168,7 @@ pub fn try_const_isize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<
                 SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
                 _ => unreachable!(),
             };
-            let subst = convert_args_for_result(interner, unevaluated_const.args.as_slice());
+            let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);
             let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);
             try_const_isize(db, &ec)
         }

src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs

@@ -568,7 +568,7 @@ impl InferenceContext<'_> {
         let supplied_sig = self.supplied_sig_of_closure(body, ret_type, arg_types, closure_kind);
 
         let snapshot = self.table.snapshot();
-        if !self.table.unify(&expected_sig.substitution, &supplied_sig.expected_sig.substitution) {
+        if !self.table.unify::<_, crate::next_solver::GenericArgs<'_>>(&expected_sig.substitution.0, &supplied_sig.expected_sig.substitution.0) {
             self.table.rollback_to(snapshot);
         }
 

src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs

@@ -7,22 +7,20 @@
 
 use std::iter;
 
-use chalk_ir::{BoundVar, Goal, Mutability, TyKind, TyVariableKind, cast::Cast};
-use hir_def::{hir::ExprId, lang_item::LangItem};
+use chalk_ir::{BoundVar, Mutability, TyKind, TyVariableKind, cast::Cast};
+use hir_def::{
+    hir::ExprId,
+    lang_item::LangItem,
+};
+use rustc_type_ir::solve::Certainty;
 use stdx::always;
 use triomphe::Arc;
 
 use crate::{
-    Canonical, DomainGoal, FnAbi, FnPointer, FnSig, InEnvironment, Interner, Lifetime,
-    Substitution, TraitEnvironment, Ty, TyBuilder, TyExt,
-    autoderef::{Autoderef, AutoderefKind},
-    db::HirDatabase,
-    infer::{
+    autoderef::{Autoderef, AutoderefKind}, db::HirDatabase, infer::{
         Adjust, Adjustment, AutoBorrow, InferOk, InferenceContext, OverloadedDeref, PointerCast,
         TypeError, TypeMismatch,
-    },
-    traits::NextTraitSolveResult,
-    utils::ClosureSubst,
+    }, utils::ClosureSubst, Canonical, FnAbi, FnPointer, FnSig, Goal, InEnvironment, Interner, Lifetime, Substitution, TraitEnvironment, Ty, TyBuilder, TyExt
 };
 
 use super::unify::InferenceTable;
@@ -42,7 +40,7 @@ fn simple(kind: Adjust) -> impl FnOnce(Ty) -> Vec<Adjustment> {
 fn success(
     adj: Vec<Adjustment>,
     target: Ty,
-    goals: Vec<InEnvironment<Goal<Interner>>>,
+    goals: Vec<InEnvironment<Goal>>,
 ) -> CoerceResult {
     Ok(InferOk { goals, value: (adj, target) })
 }
@@ -304,7 +302,7 @@ impl InferenceTable<'_> {
     fn coerce_inner(&mut self, from_ty: Ty, to_ty: &Ty, coerce_never: CoerceNever) -> CoerceResult {
         if from_ty.is_never() {
             if let TyKind::InferenceVar(tv, TyVariableKind::General) = to_ty.kind(Interner) {
-                self.set_diverging(*tv, true);
+                self.set_diverging(*tv, TyVariableKind::General, true);
             }
             if coerce_never == CoerceNever::Yes {
                 // Subtle: If we are coercing from `!` to `?T`, where `?T` is an unbound
@@ -707,41 +705,15 @@ impl InferenceTable<'_> {
             b.push(coerce_from).push(to_ty.clone()).build()
         };
 
-        let goal: InEnvironment<DomainGoal> =
-            InEnvironment::new(&self.trait_env.env, coerce_unsized_tref.cast(Interner));
-
-        let canonicalized = self.canonicalize_with_free_vars(goal);
-
-        // FIXME: rustc's coerce_unsized is more specialized -- it only tries to
-        // solve `CoerceUnsized` and `Unsize` goals at this point and leaves the
-        // rest for later. Also, there's some logic about sized type variables.
-        // Need to find out in what cases this is necessary
-        let solution = self.db.trait_solve(
-            krate,
-            self.trait_env.block,
-            canonicalized.value.clone().cast(Interner),
-        );
-
-        match solution {
-            // FIXME: this is a weaker guarantee than Chalk's `Guidance::Unique`
-            // was. Chalk's unique guidance at least guarantees that the real solution
-            // is some "subset" of the solutions matching the guidance, but the
-            // substs for `Certainty::No` don't have that same guarantee (I think).
-            NextTraitSolveResult::Certain(v) => {
-                canonicalized.apply_solution(
-                    self,
-                    Canonical {
-                        binders: v.binders,
-                        // FIXME handle constraints
-                        value: v.value.subst,
-                    },
-                );
-            }
-            // ...so, should think about how to get some actually get some guidance here
-            NextTraitSolveResult::Uncertain(..) | NextTraitSolveResult::NoSolution => {
-                return Err(TypeError);
+        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),
             }
-        }
+        })?;
 
         let unsize =
             Adjustment { kind: Adjust::Pointer(PointerCast::Unsize), target: to_ty.clone() };

src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs

@@ -23,28 +23,9 @@ use stdx::always;
 use syntax::ast::RangeOp;
 
 use crate::{
-    Adjust, Adjustment, AdtId, AutoBorrow, Binders, CallableDefId, CallableSig, DeclContext,
-    DeclOrigin, IncorrectGenericsLenKind, Interner, Rawness, Scalar, Substitution,
-    TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind,
-    autoderef::{Autoderef, builtin_deref, deref_by_trait},
-    consteval,
-    generics::generics,
-    infer::{
-        BreakableKind,
-        coerce::{CoerceMany, CoerceNever, CoercionCause},
-        find_continuable,
-        pat::contains_explicit_ref_binding,
-    },
-    lang_items::lang_items_for_bin_op,
-    lower::{
-        LifetimeElisionKind, ParamLoweringMode, lower_to_chalk_mutability,
-        path::{GenericArgsLowerer, TypeLikeConst, substs_from_args_and_bindings},
-    },
-    mapping::{ToChalk, from_chalk},
-    method_resolution::{self, VisibleFromModule},
-    primitive::{self, UintTy},
-    static_lifetime, to_chalk_trait_id,
-    traits::FnTrait,
+    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
 };
 
 use super::{
@@ -826,7 +807,7 @@ impl InferenceContext<'_> {
                 let index_ty = self.infer_expr(*index, &Expectation::none(), ExprIsRead::Yes);
 
                 if let Some(index_trait) = self.resolve_lang_trait(LangItem::Index) {
-                    let canonicalized = self.canonicalize(base_ty.clone());
+                    let canonicalized = ChalkToNextSolver::from_nextsolver(self.canonicalize(base_ty.clone().to_nextsolver(self.table.interner)), self.table.interner);
                     let receiver_adjustments = method_resolution::resolve_indexing_op(
                         self.db,
                         self.table.trait_env.clone(),
@@ -932,6 +913,7 @@ impl InferenceContext<'_> {
                     }
                     None => {
                         let expected_ty = expected.to_option(&mut self.table);
+                        tracing::debug!(?expected_ty);
                         let opt_ty = match expected_ty.as_ref().map(|it| it.kind(Interner)) {
                             Some(TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_))) => expected_ty,
                             Some(TyKind::Scalar(Scalar::Char)) => {
@@ -1678,7 +1660,7 @@ impl InferenceContext<'_> {
             None => {
                 // no field found, lets attempt to resolve it like a function so that IDE things
                 // work out while people are typing
-                let canonicalized_receiver = self.canonicalize(receiver_ty.clone());
+                let canonicalized_receiver = self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));
                 let resolved = method_resolution::lookup_method(
                     self.db,
                     &canonicalized_receiver,
@@ -1824,7 +1806,7 @@ impl InferenceContext<'_> {
         expected: &Expectation,
     ) -> Ty {
         let receiver_ty = self.infer_expr_inner(receiver, &Expectation::none(), ExprIsRead::Yes);
-        let canonicalized_receiver = self.canonicalize(receiver_ty.clone());
+        let canonicalized_receiver = self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));
 
         let resolved = method_resolution::lookup_method(
             self.db,

src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs

@@ -10,15 +10,7 @@ use hir_expand::name::Name;
 use stdx::never;
 
 use crate::{
-    InferenceDiagnostic, Interner, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt,
-    TyKind, ValueTyDefId,
-    builder::ParamKind,
-    consteval, error_lifetime,
-    generics::generics,
-    infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext,
-    lower::LifetimeElisionKind,
-    method_resolution::{self, VisibleFromModule},
-    to_chalk_trait_id,
+    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
 };
 
 use super::{ExprOrPatId, InferenceContext, InferenceTyDiagnosticSource};
@@ -322,7 +314,7 @@ impl InferenceContext<'_> {
             return Some(result);
         }
 
-        let canonical_ty = self.canonicalize(ty.clone());
+        let canonical_ty = self.canonicalize(ty.clone().to_nextsolver(self.table.interner));
 
         let mut not_visible = None;
         let res = method_resolution::iterate_method_candidates(