relate: first alias, then infer

we'd just generalize the alias and emit an alias-relate goal regardless

Author: lcnr

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -377,19 +377,20 @@ impl<'b, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'b, 'tcx> {
                 );
             }
 
+            (_, ty::Alias(..)) | (ty::Alias(..), _) if infcx.next_trait_solver() => {
+                self.register_alias_relate_predicate(a, b);
+            }
+
             (&ty::Infer(ty::TyVar(a_vid)), _) => {
                 infcx.instantiate_ty_var(self, true, a_vid, self.ambient_variance, b)?
             }
 
             (
                 &ty::Alias(ty::Opaque, ty::AliasTy { def_id: a_def_id, .. }),
                 &ty::Alias(ty::Opaque, ty::AliasTy { def_id: b_def_id, .. }),
-            ) if a_def_id == b_def_id || infcx.next_trait_solver() => {
+            ) if a_def_id == b_def_id => {
+                debug_assert!(!infcx.next_trait_solver());
                 super_combine_tys(&infcx.infcx, self, a, b).map(|_| ()).or_else(|err| {
-                    // This behavior is only there for the old solver, the new solver
-                    // shouldn't ever fail. Instead, it unconditionally emits an
-                    // alias-relate goal.
-                    assert!(!self.type_checker.infcx.next_trait_solver());
                     self.cx().dcx().span_delayed_bug(
                         self.span(),
                         "failure to relate an opaque to itself should result in an error later on",
@@ -399,7 +400,7 @@ impl<'b, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'b, 'tcx> {
             }
             (&ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }), _)
             | (_, &ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }))
-                if def_id.is_local() && !self.type_checker.infcx.next_trait_solver() =>
+                if def_id.is_local() =>
             {
                 self.relate_opaques(a, b)?;
             }

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -279,6 +279,8 @@ impl<'tcx> InferCtxt<'tcx> {
             normalize,
         };
 
+        debug!(?root_vid, ?generalizer.root_term, "generalize");
+
         let value_may_be_infer = generalizer.relate(source_term, source_term)?;
         Ok(Generalization { value_may_be_infer })
     }
@@ -443,7 +445,7 @@ impl<'tcx> Generalizer<'_, 'tcx> {
                 let normalized_alias = (self.normalize)(alias);
 
                 self.state = GeneralizerState::ShallowStructurallyRelateAliases;
-                // recursively generalize, treat the outer alias as rigid to avoid infinite recursion
+                // recursively generalize, trCeat the outer alias as rigid to avoid infinite recursion
                 let res = self.relate(normalized_alias, normalized_alias);
 
                 // only one way to get here

compiler/rustc_type_ir/src/relate.rs

@@ -20,7 +20,7 @@ pub type RelateResult<I, T> = Result<T, TypeError<I>>;
 /// This should always be `No` unless in a few special-cases when
 /// instantiating canonical responses and in the new solver. Each
 /// such case should have a comment explaining why it is used.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum StructurallyRelateAliases {
     Yes,
     No,

compiler/rustc_type_ir/src/relate/combine.rs

@@ -117,19 +117,14 @@ where
             panic!("We do not expect to encounter `Fresh` variables in the new solver")
         }
 
-        (_, ty::Alias(..)) | (ty::Alias(..), _) if infcx.next_trait_solver() => {
-            match relation.structurally_relate_aliases() {
-                StructurallyRelateAliases::Yes => structurally_relate_tys(relation, a, b),
-                StructurallyRelateAliases::No => {
-                    relation.register_alias_relate_predicate(a, b);
-                    Ok(a)
-                }
-            }
-        }
-
         // All other cases of inference are errors
         (ty::Infer(_), _) | (_, ty::Infer(_)) => Err(TypeError::Sorts(ExpectedFound::new(a, b))),
 
+        (ty::Alias(..), _) | (_, ty::Alias(..)) if infcx.next_trait_solver() => {
+            assert_eq!(relation.structurally_relate_aliases(), StructurallyRelateAliases::Yes);
+            structurally_relate_tys(relation, a, b)
+        }
+
         (ty::Alias(ty::Opaque, _), _) | (_, ty::Alias(ty::Opaque, _)) => {
             assert!(!infcx.next_trait_solver());
             match infcx.typing_mode() {

compiler/rustc_type_ir/src/relate/solver_relating.rs

@@ -203,6 +203,12 @@ where
         }
 
         match (a.kind(), b.kind()) {
+            (_, ty::Alias(..)) | (ty::Alias(..), _)
+                if matches!(self.structurally_relate_aliases, StructurallyRelateAliases::No) =>
+            {
+                self.register_alias_relate_predicate(a, b);
+            }
+
             (ty::Infer(ty::TyVar(a_id)), ty::Infer(ty::TyVar(b_id))) => {
                 match self.ambient_variance {
                     ty::Covariant => {

tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.current.fixed

@@ -8,6 +8,5 @@ fn main() {
     //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
     let _ = (-10..=10).find(|x: &i32| x.signum() == 0);
     //[current]~^ ERROR type mismatch in closure arguments
-    //[next]~^^ ERROR expected `RangeInclusive<{integer}>` to be an iterator that yields `&&i32`, but it yields `{integer}`
-    //[next]~| ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
+    //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
 }

tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.next.stderr

@@ -12,12 +12,6 @@ LL |     let _ = (-10..=10).find(|x: i32| x.signum() == 0);
 note: required by a bound in `find`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
-error[E0271]: expected `RangeInclusive<{integer}>` to be an iterator that yields `&&i32`, but it yields `{integer}`
-  --> $DIR/closure-arg-type-mismatch-issue-45727.rs:9:24
-   |
-LL |     let _ = (-10..=10).find(|x: &&&i32| x.signum() == 0);
-   |                        ^^^^ expected `&&i32`, found integer
-
 error[E0277]: expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found `{closure@$DIR/closure-arg-type-mismatch-issue-45727.rs:9:29: 9:40}`
   --> $DIR/closure-arg-type-mismatch-issue-45727.rs:9:29
    |
@@ -32,7 +26,6 @@ LL |     let _ = (-10..=10).find(|x: &&&i32| x.signum() == 0);
 note: required by a bound in `find`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0271, E0277.
-For more information about an error, try `rustc --explain E0271`.
+For more information about this error, try `rustc --explain E0277`.

tests/ui/mismatched_types/closure-arg-type-mismatch-issue-45727.rs

@@ -8,6 +8,5 @@ fn main() {
     //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
     let _ = (-10..=10).find(|x: &&&i32| x.signum() == 0);
     //[current]~^ ERROR type mismatch in closure arguments
-    //[next]~^^ ERROR expected `RangeInclusive<{integer}>` to be an iterator that yields `&&i32`, but it yields `{integer}`
-    //[next]~| ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
+    //[next]~^^ ERROR expected a `FnMut(&<std::ops::RangeInclusive<{integer}> as Iterator>::Item)` closure, found
 }