Do not emit alias-eq when instantiating a type var from a canonical response in the new solver

compiler/rustc_infer/src/infer/combine.rs

@@ -58,6 +58,10 @@ pub struct CombineFields<'infcx, 'tcx> {
     /// matching from matching anything against opaque
     /// types.
     pub define_opaque_types: bool,
+    /// Used in [`CombineFields::instantiate`] to ensure that when we relate
+    /// a type and its generalized type, we never emit an alias-eq goal, but
+    /// instead relate via substs.
+    pub relate_projections_via_substs: bool,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -420,16 +424,16 @@ impl<'infcx, 'tcx> CombineFields<'infcx, 'tcx> {
         // relations wind up attributed to the same spans. We need
         // to associate causes/spans with each of the relations in
         // the stack to get this right.
-        match dir {
-            EqTo => self.equate(a_is_expected).relate(a_ty, b_ty),
-            SubtypeOf => self.sub(a_is_expected).relate(a_ty, b_ty),
-            SupertypeOf => self.sub(a_is_expected).relate_with_variance(
+        self.eager_relate_projections_via_substs(|this| match dir {
+            EqTo => this.equate(a_is_expected).relate(a_ty, b_ty),
+            SubtypeOf => this.sub(a_is_expected).relate(a_ty, b_ty),
+            SupertypeOf => this.sub(a_is_expected).relate_with_variance(
                 ty::Contravariant,
                 ty::VarianceDiagInfo::default(),
                 a_ty,
                 b_ty,
             ),
-        }?;
+        })?;
 
         Ok(())
     }
@@ -492,6 +496,14 @@ impl<'infcx, 'tcx> CombineFields<'infcx, 'tcx> {
         Ok(Generalization { ty, needs_wf })
     }
 
+    // Relate projections via their substs eagerly, and never via an `AliasEq` goal
+    pub fn eager_relate_projections_via_substs<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T {
+        let old = std::mem::replace(&mut self.relate_projections_via_substs, true);
+        let v = f(self);
+        self.relate_projections_via_substs = old;
+        v
+    }
+
     pub fn register_obligations(&mut self, obligations: PredicateObligations<'tcx>) {
         self.obligations.extend(obligations.into_iter());
     }

compiler/rustc_infer/src/infer/equate.rs

@@ -144,6 +144,13 @@ impl<'tcx> TypeRelation<'tcx> for Equate<'_, '_, 'tcx> {
                 }
             }
 
+            // Inside the generalizer, we want to related projections by substs eagerly.
+            (&ty::Alias(ty::Projection, a_data), &ty::Alias(ty::Projection, b_data))
+                if self.fields.relate_projections_via_substs =>
+            {
+                self.relate(a_data, b_data)?;
+            }
+
             _ => {
                 self.fields.infcx.super_combine_tys(self, a, b)?;
             }

compiler/rustc_infer/src/infer/mod.rs

@@ -738,6 +738,7 @@ impl<'tcx> InferCtxt<'tcx> {
             param_env,
             obligations: PredicateObligations::new(),
             define_opaque_types,
+            relate_projections_via_substs: false,
         }
     }
 

compiler/rustc_infer/src/infer/sub.rs

@@ -172,6 +172,14 @@ impl<'tcx> TypeRelation<'tcx> for Sub<'_, '_, 'tcx> {
                 }
             }
 
+            // Inside the generalizer, we want to related projections by substs eagerly.
+            (&ty::Alias(ty::Projection, a_data), &ty::Alias(ty::Projection, b_data))
+                if self.fields.relate_projections_via_substs =>
+            {
+                let projection_ty = self.relate(a_data, b_data)?;
+                Ok(self.tcx().mk_alias(ty::Projection, projection_ty))
+            }
+
             _ => {
                 self.fields.infcx.super_combine_tys(self, a, b)?;
                 Ok(a)

tests/ui/traits/new-solver/generalize-shouldnt-emit-alias-eq.rs

@@ -0,0 +1,40 @@
+// check-pass
+// compile-flags: -Ztrait-solver=next
+
+trait Foo {
+    type Gat<'a>
+    where
+        Self: 'a;
+    fn bar(&self) -> Self::Gat<'_>;
+}
+
+enum Option<T> {
+    Some(T),
+    None,
+}
+
+impl<T> Option<T> {
+    fn as_ref(&self) -> Option<&T> {
+        match self {
+            Option::Some(t) => Option::Some(t),
+            Option::None => Option::None,
+        }
+    }
+
+    fn map<U>(self, f: impl FnOnce(T) -> U) -> Option<U> {
+        match self {
+            Option::Some(t) => Option::Some(f(t)),
+            Option::None => Option::None,
+        }
+    }
+}
+
+impl<T: Foo + 'static> Foo for Option<T> {
+    type Gat<'a> = Option<<T as Foo>::Gat<'a>> where Self: 'a;
+
+    fn bar(&self) -> Self::Gat<'_> {
+        self.as_ref().map(Foo::bar)
+    }
+}
+
+fn main() {}