Properly handle normalization

Previously normalization was broken, which caused a lot of fake errors.

This fix most type mismatches of the new solver, and it also reverts many test regressions.

The downside is that now `chalk_ir::TyKind::AssociatedType`/`chalk_ir::TyKind::Alias` cannot be trusted anymore with their roles, namely: `AssociatedType` is always fully normalized and `Alias` only if it can possibly be normalized further. That seems okay as the new solver does not have this distinction at all (due to it being a lazy normalizer), so this will only hold for the migration time. This does mean we have to change some APIs, notably `hir::Type::walk()` and `TyFingerprint`, to treat `Alias` the same as `AssociatedType`.

Another small thing this commit does is to isolate processing of user-written types (currently involving replacing error types and normalizing, but in the future validation will also be needed) to separate functions.

Author: ChayimFriedman2

crates/hir-ty/src/infer.rs

@@ -54,6 +54,8 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use stdx::{always, never};
 use triomphe::Arc;
 
+use crate::next_solver::DbInterner;
+use crate::next_solver::mapping::NextSolverToChalk;
 use crate::{
     AliasEq, AliasTy, Binders, ClosureId, Const, DomainGoal, GenericArg, ImplTraitId, ImplTraitIdx,
     IncorrectGenericsLenKind, Interner, Lifetime, OpaqueTyId, ParamLoweringMode,
@@ -922,13 +924,15 @@ impl<'db> InferenceContext<'db> {
         });
         diagnostics.shrink_to_fit();
         for (_, subst) in method_resolutions.values_mut() {
-            *subst = table.resolve_completely(subst.clone());
+            *subst =
+                table.resolve_completely::<_, crate::next_solver::GenericArgs<'db>>(subst.clone());
             *has_errors =
                 *has_errors || subst.type_parameters(Interner).any(|ty| ty.contains_unknown());
         }
         method_resolutions.shrink_to_fit();
         for (_, subst) in assoc_resolutions.values_mut() {
-            *subst = table.resolve_completely(subst.clone());
+            *subst =
+                table.resolve_completely::<_, crate::next_solver::GenericArgs<'db>>(subst.clone());
             *has_errors =
                 *has_errors || subst.type_parameters(Interner).any(|ty| ty.contains_unknown());
         }
@@ -946,7 +950,12 @@ impl<'db> InferenceContext<'db> {
         result.tuple_field_access_types = tuple_field_accesses_rev
             .into_iter()
             .enumerate()
-            .map(|(idx, subst)| (TupleId(idx as u32), table.resolve_completely(subst)))
+            .map(|(idx, subst)| {
+                (
+                    TupleId(idx as u32),
+                    table.resolve_completely::<_, crate::next_solver::GenericArgs<'db>>(subst),
+                )
+            })
             .inspect(|(_, subst)| {
                 *has_errors =
                     *has_errors || subst.type_parameters(Interner).any(|ty| ty.contains_unknown());
@@ -1015,14 +1024,12 @@ impl<'db> InferenceContext<'db> {
         if let Some(self_param) = self.body.self_param
             && let Some(ty) = param_tys.next()
         {
-            let ty = self.insert_type_vars(ty);
-            let ty = self.normalize_associated_types_in(ty);
+            let ty = self.process_user_written_ty(ty);
             self.write_binding_ty(self_param, ty);
         }
         let mut tait_candidates = FxHashSet::default();
         for (ty, pat) in param_tys.zip(&*self.body.params) {
-            let ty = self.insert_type_vars(ty);
-            let ty = self.normalize_associated_types_in(ty);
+            let ty = self.process_user_written_ty(ty);
 
             self.infer_top_pat(*pat, &ty, None);
             if ty
@@ -1073,7 +1080,7 @@ impl<'db> InferenceContext<'db> {
             None => self.result.standard_types.unit.clone(),
         };
 
-        self.return_ty = self.normalize_associated_types_in(return_ty);
+        self.return_ty = self.process_user_written_ty(return_ty);
         self.return_coercion = Some(CoerceMany::new(self.return_ty.clone()));
 
         // Functions might be defining usage sites of TAITs.
@@ -1415,8 +1422,7 @@ impl<'db> InferenceContext<'db> {
     ) -> Ty {
         let ty = self
             .with_ty_lowering(store, type_source, lifetime_elision, |ctx| ctx.lower_ty(type_ref));
-        let ty = self.insert_type_vars(ty);
-        self.normalize_associated_types_in(ty)
+        self.process_user_written_ty(ty)
     }
 
     fn make_body_ty(&mut self, type_ref: TypeRefId) -> Ty {
@@ -1562,15 +1568,35 @@ impl<'db> InferenceContext<'db> {
         ty
     }
 
+    /// Whenever you lower a user-written type, you should call this.
+    fn process_user_written_ty<T, U>(&mut self, ty: T) -> T
+    where
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
+        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
+    {
+        self.table.process_user_written_ty(ty)
+    }
+
+    /// The difference of this method from `process_user_written_ty()` is that this method doesn't register a well-formed obligation,
+    /// while `process_user_written_ty()` should (but doesn't currently).
+    fn process_remote_user_written_ty<T, U>(&mut self, ty: T) -> T
+    where
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
+        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
+    {
+        self.table.process_remote_user_written_ty(ty)
+    }
+
     /// Recurses through the given type, normalizing associated types mentioned
     /// in it by replacing them by type variables and registering obligations to
     /// resolve later. This should be done once for every type we get from some
     /// type annotation (e.g. from a let type annotation, field type or function
     /// call). `make_ty` handles this already, but e.g. for field types we need
     /// to do it as well.
-    fn normalize_associated_types_in<T>(&mut self, ty: T) -> T
+    fn normalize_associated_types_in<T, U>(&mut self, ty: T) -> T
     where
-        T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
+        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
         self.table.normalize_associated_types_in(ty)
     }

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

@@ -53,7 +53,7 @@ pub(super) struct ClosureSignature {
     pub(super) expected_sig: FnPointer,
 }
 
-impl InferenceContext<'_> {
+impl<'db> InferenceContext<'db> {
     pub(super) fn infer_closure(
         &mut self,
         body: &ExprId,
@@ -71,9 +71,13 @@ impl InferenceContext<'_> {
             None => (None, None),
         };
 
-        let ClosureSignature { expected_sig: bound_sig, ret_ty: body_ret_ty } =
+        let ClosureSignature { expected_sig: mut bound_sig, ret_ty: body_ret_ty } =
             self.sig_of_closure(body, ret_type, arg_types, closure_kind, expected_sig);
-        let bound_sig = self.normalize_associated_types_in(bound_sig);
+        bound_sig.substitution.0 = self
+            .normalize_associated_types_in::<_, crate::next_solver::GenericArgs<'db>>(
+                bound_sig.substitution.0,
+            );
+        let bound_sig = bound_sig;
         let sig_ty = TyKind::Function(bound_sig.clone()).intern(Interner);
 
         let (id, ty, resume_yield_tys) = match closure_kind {

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

@@ -1419,7 +1419,7 @@ impl InferenceContext<'_> {
             None => self.err_ty(),
         };
 
-        let ret_ty = self.normalize_associated_types_in(ret_ty);
+        let ret_ty = self.process_remote_user_written_ty(ret_ty);
 
         if self.is_builtin_binop(&lhs_ty, &rhs_ty, op) {
             // use knowledge of built-in binary ops, which can sometimes help inference
@@ -1630,8 +1630,7 @@ impl InferenceContext<'_> {
         Some(match res {
             Some((field_id, ty)) => {
                 let adjustments = auto_deref_adjust_steps(&autoderef);
-                let ty = self.insert_type_vars(ty);
-                let ty = self.normalize_associated_types_in(ty);
+                let ty = self.process_remote_user_written_ty(ty);
 
                 (ty, field_id, adjustments, true)
             }
@@ -1641,8 +1640,7 @@ impl InferenceContext<'_> {
                 let ty = self.db.field_types(field_id.parent)[field_id.local_id]
                     .clone()
                     .substitute(Interner, &subst);
-                let ty = self.insert_type_vars(ty);
-                let ty = self.normalize_associated_types_in(ty);
+                let ty = self.process_remote_user_written_ty(ty);
 
                 (ty, Either::Left(field_id), adjustments, false)
             }

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

@@ -88,7 +88,7 @@ impl InferenceContext<'_> {
                                     Some(substs) => f.substitute(Interner, substs),
                                     None => f.substitute(Interner, &Substitution::empty(Interner)),
                                 };
-                                self.normalize_associated_types_in(expected_ty)
+                                self.process_remote_user_written_ty(expected_ty)
                             }
                             None => self.err_ty(),
                         }
@@ -152,7 +152,7 @@ impl InferenceContext<'_> {
                                     Some(substs) => f.substitute(Interner, substs),
                                     None => f.substitute(Interner, &Substitution::empty(Interner)),
                                 };
-                                self.normalize_associated_types_in(expected_ty)
+                                self.process_remote_user_written_ty(expected_ty)
                             }
                             None => {
                                 self.push_diagnostic(InferenceDiagnostic::NoSuchField {

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

@@ -23,21 +23,21 @@ use crate::{
 
 use super::{ExprOrPatId, InferenceContext, InferenceTyDiagnosticSource};
 
-impl InferenceContext<'_> {
+impl<'db> InferenceContext<'db> {
     pub(super) fn infer_path(&mut self, path: &Path, id: ExprOrPatId) -> Option<Ty> {
         let (value_def, generic_def, substs) = match self.resolve_value_path(path, id)? {
             ValuePathResolution::GenericDef(value_def, generic_def, substs) => {
                 (value_def, generic_def, substs)
             }
             ValuePathResolution::NonGeneric(ty) => return Some(ty),
         };
-        let substs = self.insert_type_vars(substs);
-        let substs = self.normalize_associated_types_in(substs);
+        let substs =
+            self.process_remote_user_written_ty::<_, crate::next_solver::GenericArgs<'db>>(substs);
 
         self.add_required_obligations_for_value_path(generic_def, &substs);
 
         let ty = self.db.value_ty(value_def)?.substitute(Interner, &substs);
-        let ty = self.normalize_associated_types_in(ty);
+        let ty = self.process_remote_user_written_ty(ty);
         Some(ty)
     }
 
@@ -173,14 +173,12 @@ impl InferenceContext<'_> {
             let last = path.segments().last()?;
 
             let (ty, orig_ns) = path_ctx.ty_ctx().lower_ty_ext(type_ref);
-            let ty = self.table.insert_type_vars(ty);
-            let ty = self.table.normalize_associated_types_in(ty);
+            let ty = self.table.process_user_written_ty(ty);
 
             path_ctx.ignore_last_segment();
             let (ty, _) = path_ctx.lower_ty_relative_path(ty, orig_ns, true);
             drop_ctx(ctx, no_diagnostics);
-            let ty = self.table.insert_type_vars(ty);
-            let ty = self.table.normalize_associated_types_in(ty);
+            let ty = self.table.process_user_written_ty(ty);
             self.resolve_ty_assoc_item(ty, last.name, id).map(|(it, substs)| (it, Some(substs)))?
         } else {
             let hygiene = self.body.expr_or_pat_path_hygiene(id);
@@ -223,8 +221,7 @@ impl InferenceContext<'_> {
                                 return None;
                             }
 
-                            let ty = self.insert_type_vars(ty);
-                            let ty = self.normalize_associated_types_in(ty);
+                            let ty = self.process_user_written_ty(ty);
 
                             self.resolve_ty_assoc_item(ty, last_segment.name, id)
                         }