Emit ProjectionEq obligations when relating projections

Author: BoxyUwU

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -4,7 +4,7 @@ use rustc_infer::traits::ObligationCause;
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::relate::TypeRelation;
-use rustc_middle::ty::{self, Const, Ty};
+use rustc_middle::ty::{self, Const, ToPredicate, Ty};
 use rustc_span::Span;
 use rustc_trait_selection::traits::query::Fallible;
 
@@ -147,6 +147,14 @@ impl<'tcx> TypeRelatingDelegate<'tcx> for NllTypeRelatingDelegate<'_, '_, 'tcx>
     // 'static.
     fn const_equate(&mut self, _a: Const<'tcx>, _b: Const<'tcx>) {}
 
+    fn projection_equate(&mut self, projection_ty: ty::ProjectionTy<'tcx>, ty: Ty<'tcx>) {
+        unreachable!()
+    }
+
+    fn defer_projection_equality(&self) -> bool {
+        false
+    }
+
     fn normalization() -> NormalizationStrategy {
         NormalizationStrategy::Eager
     }

compiler/rustc_error_codes/src/error_codes/E0275.md

@@ -8,6 +8,12 @@ trait Foo {}
 struct Bar<T>(T);
 
 impl<T> Foo for T where Bar<T>: Foo {}
+
+fn takes_foo<T: Foo>() {}
+
+fn calls_takes_foo() {
+    takes_foo::<()>();
+}
 ```
 
 This error occurs when there was a recursive trait requirement that overflowed

compiler/rustc_infer/src/infer/at.rs

@@ -40,6 +40,7 @@ pub struct At<'a, 'tcx> {
     /// matching from matching anything against opaque
     /// types.
     pub define_opaque_types: bool,
+    pub defer_projection_equality: bool,
 }
 
 pub struct Trace<'a, 'tcx> {
@@ -55,7 +56,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         cause: &'a ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
     ) -> At<'a, 'tcx> {
-        At { infcx: self, cause, param_env, define_opaque_types: true }
+        At {
+            infcx: self,
+            cause,
+            param_env,
+            define_opaque_types: true,
+            defer_projection_equality: true,
+        }
     }
 
     /// Forks the inference context, creating a new inference context with the same inference
@@ -101,6 +108,10 @@ impl<'a, 'tcx> At<'a, 'tcx> {
         Self { define_opaque_types, ..self }
     }
 
+    pub fn defer_projection_equality(self, defer_projection_equality: bool) -> Self {
+        Self { defer_projection_equality, ..self }
+    }
+
     /// Hacky routine for equating two impl headers in coherence.
     pub fn eq_impl_headers(
         self,
@@ -252,7 +263,12 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
     {
         let Trace { at, trace, a_is_expected } = self;
         at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env, at.define_opaque_types);
+            let mut fields = at.infcx.combine_fields(
+                trace,
+                at.param_env,
+                at.define_opaque_types,
+                at.defer_projection_equality,
+            );
             fields
                 .sub(a_is_expected)
                 .relate(a, b)
@@ -269,7 +285,12 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
     {
         let Trace { at, trace, a_is_expected } = self;
         at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env, at.define_opaque_types);
+            let mut fields = at.infcx.combine_fields(
+                trace,
+                at.param_env,
+                at.define_opaque_types,
+                at.defer_projection_equality,
+            );
             fields
                 .equate(a_is_expected)
                 .relate(a, b)
@@ -284,7 +305,12 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
     {
         let Trace { at, trace, a_is_expected } = self;
         at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env, at.define_opaque_types);
+            let mut fields = at.infcx.combine_fields(
+                trace,
+                at.param_env,
+                at.define_opaque_types,
+                at.defer_projection_equality,
+            );
             fields
                 .lub(a_is_expected)
                 .relate(a, b)
@@ -299,7 +325,12 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
     {
         let Trace { at, trace, a_is_expected } = self;
         at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env, at.define_opaque_types);
+            let mut fields = at.infcx.combine_fields(
+                trace,
+                at.param_env,
+                at.define_opaque_types,
+                at.defer_projection_equality,
+            );
             fields
                 .glb(a_is_expected)
                 .relate(a, b)

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -733,6 +733,23 @@ impl<'tcx> TypeRelatingDelegate<'tcx> for QueryTypeRelatingDelegate<'_, 'tcx> {
         span_bug!(self.cause.span(), "generic_const_exprs: unreachable `const_equate`");
     }
 
+    fn projection_equate(&mut self, projection_ty: ty::ProjectionTy<'tcx>, ty: Ty<'tcx>) {
+        self.obligations.push(Obligation {
+            cause: self.cause.clone(),
+            param_env: self.param_env,
+            predicate: ty::Binder::dummy(ty::PredicateKind::Projection(ty::ProjectionPredicate {
+                projection_ty,
+                term: ty::Term::from(ty),
+            }))
+            .to_predicate(self.infcx.tcx),
+            recursion_depth: 0,
+        })
+    }
+
+    fn defer_projection_equality(&self) -> bool {
+        true
+    }
+
     fn normalization() -> NormalizationStrategy {
         NormalizationStrategy::Eager
     }

compiler/rustc_infer/src/infer/combine.rs

@@ -54,6 +54,7 @@ pub struct CombineFields<'infcx, 'tcx> {
     /// matching from matching anything against opaque
     /// types.
     pub define_opaque_types: bool,
+    pub defer_projection_equality: bool,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -457,6 +458,19 @@ impl<'infcx, 'tcx> CombineFields<'infcx, 'tcx> {
             ty::Binder::dummy(predicate).to_predicate(self.tcx()),
         ));
     }
+
+    pub fn add_projection_equate_obligation(
+        &mut self,
+        projection_ty: ty::ProjectionTy<'tcx>,
+        ty: Ty<'tcx>,
+    ) {
+        self.obligations.push(Obligation::new(
+            self.trace.cause.clone(),
+            self.param_env,
+            ty::Binder::dummy(ty::ProjectionPredicate { projection_ty, term: ty::Term::from(ty) })
+                .to_predicate(self.tcx()),
+        ));
+    }
 }
 
 struct Generalizer<'cx, 'tcx> {
@@ -759,6 +773,18 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
             _ => relate::super_relate_consts(self, c, c),
         }
     }
+
+    fn projection_equate_obligation(
+        &mut self,
+        _projection_ty: ty::ProjectionTy<'tcx>,
+        _ty: Ty<'tcx>,
+    ) {
+        bug!("`TypeGeneralizer` shouldn't equate projections with other kinds of types");
+    }
+
+    fn defer_projection_equality(&self) -> bool {
+        bug!("`TypeGeneralizer` shouldn't equate projections with other kinds of types");
+    }
 }
 
 pub trait ConstEquateRelation<'tcx>: TypeRelation<'tcx> {
@@ -982,4 +1008,16 @@ impl<'tcx> TypeRelation<'tcx> for ConstInferUnifier<'_, 'tcx> {
             _ => relate::super_relate_consts(self, c, c),
         }
     }
+
+    fn projection_equate_obligation(
+        &mut self,
+        _projection_ty: ty::ProjectionTy<'tcx>,
+        _ty: Ty<'tcx>,
+    ) {
+        bug!("`ConstInferUnifier` shouldn't equate projections with other kinds of types");
+    }
+
+    fn defer_projection_equality(&self) -> bool {
+        bug!("`ConstInferUnifier` shouldn't equate projections with other kinds of types");
+    }
 }

compiler/rustc_infer/src/infer/equate.rs

@@ -160,6 +160,18 @@ impl<'tcx> TypeRelation<'tcx> for Equate<'_, '_, 'tcx> {
         }
         Ok(a)
     }
+
+    fn projection_equate_obligation(
+        &mut self,
+        projection_ty: ty::ProjectionTy<'tcx>,
+        ty: Ty<'tcx>,
+    ) {
+        self.fields.add_projection_equate_obligation(projection_ty, ty);
+    }
+
+    fn defer_projection_equality(&self) -> bool {
+        self.fields.defer_projection_equality
+    }
 }
 
 impl<'tcx> ConstEquateRelation<'tcx> for Equate<'_, '_, 'tcx> {

compiler/rustc_infer/src/infer/error_reporting/mod.rs

@@ -2777,6 +2777,18 @@ impl<'tcx> TypeRelation<'tcx> for SameTypeModuloInfer<'_, 'tcx> {
         // relation
         Ok(a)
     }
+
+    fn projection_equate_obligation(
+        &mut self,
+        projection_ty: ty::ProjectionTy<'tcx>,
+        ty: Ty<'tcx>,
+    ) {
+        unreachable!()
+    }
+
+    fn defer_projection_equality(&self) -> bool {
+        false
+    }
 }
 
 impl<'a, 'tcx> InferCtxt<'a, 'tcx> {

compiler/rustc_infer/src/infer/glb.rs

@@ -110,6 +110,18 @@ impl<'tcx> TypeRelation<'tcx> for Glb<'_, '_, 'tcx> {
             Ok(ty::Binder::dummy(self.relate(a.skip_binder(), b.skip_binder())?))
         }
     }
+
+    fn projection_equate_obligation(
+        &mut self,
+        projection_ty: ty::ProjectionTy<'tcx>,
+        ty: Ty<'tcx>,
+    ) {
+        self.fields.add_projection_equate_obligation(projection_ty, ty);
+    }
+
+    fn defer_projection_equality(&self) -> bool {
+        self.fields.defer_projection_equality
+    }
 }
 
 impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Glb<'combine, 'infcx, 'tcx> {

compiler/rustc_infer/src/infer/lub.rs

@@ -110,6 +110,18 @@ impl<'tcx> TypeRelation<'tcx> for Lub<'_, '_, 'tcx> {
             Ok(ty::Binder::dummy(self.relate(a.skip_binder(), b.skip_binder())?))
         }
     }
+
+    fn projection_equate_obligation(
+        &mut self,
+        projection_ty: ty::ProjectionTy<'tcx>,
+        ty: Ty<'tcx>,
+    ) {
+        self.fields.add_projection_equate_obligation(projection_ty, ty);
+    }
+
+    fn defer_projection_equality(&self) -> bool {
+        self.fields.defer_projection_equality
+    }
 }
 
 impl<'tcx> ConstEquateRelation<'tcx> for Lub<'_, '_, 'tcx> {

compiler/rustc_infer/src/infer/mod.rs

@@ -784,6 +784,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         trace: TypeTrace<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         define_opaque_types: bool,
+        defer_projection_equality: bool,
     ) -> CombineFields<'a, 'tcx> {
         CombineFields {
             infcx: self,
@@ -792,6 +793,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             param_env,
             obligations: PredicateObligations::new(),
             define_opaque_types,
+            defer_projection_equality,
         }
     }