Fix failing tests and fill-in missing details

Author: ShoyuVanilla

crates/hir-ty/src/autoderef.rs

@@ -98,7 +98,7 @@ impl<'table, 'db> Autoderef<'table, 'db> {
         explicit: bool,
         use_receiver_trait: bool,
     ) -> Self {
-        let ty = table.resolve_ty_shallow(&ty);
+        let ty = table.structurally_resolve_type(&ty);
         Autoderef { table, ty, at_start: true, steps: Vec::new(), explicit, use_receiver_trait }
     }
 
@@ -114,7 +114,7 @@ impl<'table, 'db> Autoderef<'table, 'db, usize> {
         explicit: bool,
         use_receiver_trait: bool,
     ) -> Self {
-        let ty = table.resolve_ty_shallow(&ty);
+        let ty = table.structurally_resolve_type(&ty);
         Autoderef { table, ty, at_start: true, steps: 0, explicit, use_receiver_trait }
     }
 }
@@ -160,7 +160,7 @@ pub(crate) fn autoderef_step(
     use_receiver_trait: bool,
 ) -> Option<(AutoderefKind, Ty)> {
     if let Some(derefed) = builtin_deref(table.db, &ty, explicit) {
-        Some((AutoderefKind::Builtin, table.resolve_ty_shallow(derefed)))
+        Some((AutoderefKind::Builtin, table.structurally_resolve_type(derefed)))
     } else {
         Some((AutoderefKind::Overloaded, deref_by_trait(table, ty, use_receiver_trait)?))
     }
@@ -187,7 +187,7 @@ pub(crate) fn deref_by_trait(
     use_receiver_trait: bool,
 ) -> Option<Ty> {
     let _p = tracing::info_span!("deref_by_trait").entered();
-    if table.resolve_ty_shallow(&ty).inference_var(Interner).is_some() {
+    if table.structurally_resolve_type(&ty).inference_var(Interner).is_some() {
         // don't try to deref unknown variables
         return None;
     }
@@ -232,5 +232,5 @@ pub(crate) fn deref_by_trait(
     table.register_obligation(implements_goal);
 
     let result = table.normalize_projection_ty(projection);
-    Some(table.resolve_ty_shallow(&result))
+    Some(table.structurally_resolve_type(&result))
 }

crates/hir-ty/src/chalk_ext.rs

@@ -245,26 +245,30 @@ impl TyExt for Ty {
     }
 
     fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<QuantifiedWhereClause>> {
+        let handle_async_block_type_impl_trait = |def: DefWithBodyId| {
+            let krate = def.module(db).krate();
+            if let Some(future_trait) = LangItem::Future.resolve_trait(db, krate) {
+                // This is only used by type walking.
+                // Parameters will be walked outside, and projection predicate is not used.
+                // So just provide the Future trait.
+                let impl_bound = Binders::empty(
+                    Interner,
+                    WhereClause::Implemented(TraitRef {
+                        trait_id: to_chalk_trait_id(future_trait),
+                        substitution: Substitution::empty(Interner),
+                    }),
+                );
+                Some(vec![impl_bound])
+            } else {
+                None
+            }
+        };
+
         match self.kind(Interner) {
             TyKind::OpaqueType(opaque_ty_id, subst) => {
                 match db.lookup_intern_impl_trait_id((*opaque_ty_id).into()) {
                     ImplTraitId::AsyncBlockTypeImplTrait(def, _expr) => {
-                        let krate = def.module(db).krate();
-                        if let Some(future_trait) = LangItem::Future.resolve_trait(db, krate) {
-                            // This is only used by type walking.
-                            // Parameters will be walked outside, and projection predicate is not used.
-                            // So just provide the Future trait.
-                            let impl_bound = Binders::empty(
-                                Interner,
-                                WhereClause::Implemented(TraitRef {
-                                    trait_id: to_chalk_trait_id(future_trait),
-                                    substitution: Substitution::empty(Interner),
-                                }),
-                            );
-                            Some(vec![impl_bound])
-                        } else {
-                            None
-                        }
+                        handle_async_block_type_impl_trait(def)
                     }
                     ImplTraitId::ReturnTypeImplTrait(func, idx) => {
                         db.return_type_impl_traits(func).map(|it| {
@@ -299,8 +303,9 @@ impl TyExt for Ty {
                             data.substitute(Interner, &opaque_ty.substitution)
                         })
                     }
-                    // It always has an parameter for Future::Output type.
-                    ImplTraitId::AsyncBlockTypeImplTrait(..) => unreachable!(),
+                    ImplTraitId::AsyncBlockTypeImplTrait(def, _) => {
+                        return handle_async_block_type_impl_trait(def);
+                    }
                 };
 
                 predicates.map(|it| it.into_value_and_skipped_binders().0)

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_binder_to_early_binder},
+        mapping::{ChalkToNextSolver, NextSolverToChalk, 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 = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);
+            let subst = unevaluated_const.args.to_chalk(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 = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);
+            let subst = unevaluated_const.args.to_chalk(interner);
             let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);
             try_const_isize(db, &ec)
         }

crates/hir-ty/src/infer.rs

@@ -832,6 +832,7 @@ impl<'db> InferenceContext<'db> {
             coercion_casts,
             diagnostics: _,
         } = &mut result;
+        table.resolve_obligations_as_possible();
         table.fallback_if_possible();
 
         // Comment from rustc:
@@ -1746,7 +1747,7 @@ impl<'db> InferenceContext<'db> {
 
                     ty = self.table.insert_type_vars(ty);
                     ty = self.table.normalize_associated_types_in(ty);
-                    ty = self.table.resolve_ty_shallow(&ty);
+                    ty = self.table.structurally_resolve_type(&ty);
                     if ty.is_unknown() {
                         return (self.err_ty(), None);
                     }
@@ -1817,7 +1818,7 @@ impl<'db> InferenceContext<'db> {
         let ty = match ty.kind(Interner) {
             TyKind::Alias(AliasTy::Projection(proj_ty)) => {
                 let ty = self.table.normalize_projection_ty(proj_ty.clone());
-                self.table.resolve_ty_shallow(&ty)
+                self.table.structurally_resolve_type(&ty)
             }
             _ => ty,
         };
@@ -2047,7 +2048,7 @@ impl Expectation {
     fn adjust_for_branches(&self, table: &mut unify::InferenceTable<'_>) -> Expectation {
         match self {
             Expectation::HasType(ety) => {
-                let ety = table.resolve_ty_shallow(ety);
+                let ety = table.structurally_resolve_type(ety);
                 if ety.is_ty_var() { Expectation::None } else { Expectation::HasType(ety) }
             }
             Expectation::RValueLikeUnsized(ety) => Expectation::RValueLikeUnsized(ety.clone()),

crates/hir-ty/src/infer/closure.rs

@@ -568,7 +568,10 @@ 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::<_, crate::next_solver::GenericArgs<'_>>(&expected_sig.substitution.0, &supplied_sig.expected_sig.substitution.0) {
+        if !self.table.unify::<_, crate::next_solver::GenericArgs<'_>>(
+            &expected_sig.substitution.0,
+            &supplied_sig.expected_sig.substitution.0,
+        ) {
             self.table.rollback_to(snapshot);
         }
 

crates/hir-ty/src/infer/coerce.rs

@@ -8,19 +8,21 @@
 use std::iter;
 
 use chalk_ir::{BoundVar, Mutability, TyKind, TyVariableKind, cast::Cast};
-use hir_def::{
-    hir::ExprId,
-    lang_item::LangItem,
-};
+use hir_def::{hir::ExprId, lang_item::LangItem};
 use rustc_type_ir::solve::Certainty;
 use stdx::always;
 use triomphe::Arc;
 
 use crate::{
-    autoderef::{Autoderef, AutoderefKind}, db::HirDatabase, infer::{
+    Canonical, FnAbi, FnPointer, FnSig, Goal, InEnvironment, Interner, Lifetime, Substitution,
+    TraitEnvironment, Ty, TyBuilder, TyExt,
+    autoderef::{Autoderef, AutoderefKind},
+    db::HirDatabase,
+    infer::{
         Adjust, Adjustment, AutoBorrow, InferOk, InferenceContext, OverloadedDeref, PointerCast,
         TypeError, TypeMismatch,
-    }, utils::ClosureSubst, Canonical, FnAbi, FnPointer, FnSig, Goal, InEnvironment, Interner, Lifetime, Substitution, TraitEnvironment, Ty, TyBuilder, TyExt
+    },
+    utils::ClosureSubst,
 };
 
 use super::unify::InferenceTable;
@@ -37,11 +39,7 @@ fn simple(kind: Adjust) -> impl FnOnce(Ty) -> Vec<Adjustment> {
 }
 
 /// This always returns `Ok(...)`.
-fn success(
-    adj: Vec<Adjustment>,
-    target: Ty,
-    goals: Vec<InEnvironment<Goal>>,
-) -> CoerceResult {
+fn success(adj: Vec<Adjustment>, target: Ty, goals: Vec<InEnvironment<Goal>>) -> CoerceResult {
     Ok(InferOk { goals, value: (adj, target) })
 }
 
@@ -285,8 +283,8 @@ impl InferenceTable<'_> {
         to_ty: &Ty,
         coerce_never: CoerceNever,
     ) -> Result<(Vec<Adjustment>, Ty), TypeError> {
-        let from_ty = self.resolve_ty_shallow(from_ty);
-        let to_ty = self.resolve_ty_shallow(to_ty);
+        let from_ty = self.structurally_resolve_type(from_ty);
+        let to_ty = self.structurally_resolve_type(to_ty);
         match self.coerce_inner(from_ty, &to_ty, coerce_never) {
             Ok(InferOk { value: (adjustments, ty), goals }) => {
                 self.register_infer_ok(InferOk { value: (), goals });
@@ -302,7 +300,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, TyVariableKind::General, true);
+                self.set_diverging(*tv, TyVariableKind::General);
             }
             if coerce_never == CoerceNever::Yes {
                 // Subtle: If we are coercing from `!` to `?T`, where `?T` is an unbound
@@ -707,12 +705,9 @@ impl InferenceTable<'_> {
 
         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),
-            }
+        self.commit_if_ok(|table| match table.solve_obligation(goal) {
+            Ok(Certainty::Yes) => Ok(()),
+            _ => Err(TypeError),
         })?;
 
         let unsize =