add in where equality predicate

Author: JulianKnodt

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1322,9 +1322,11 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
             generics.span,
         );
 
-        for predicate in &generics.where_clause.predicates {
-            if let WherePredicate::EqPredicate(ref predicate) = *predicate {
-                deny_equality_constraints(self, predicate, generics);
+        if !self.session.features_untracked().type_equality_constraints {
+            for predicate in &generics.where_clause.predicates {
+                if let WherePredicate::EqPredicate(ref predicate) = *predicate {
+                    deny_equality_constraints(self, predicate, generics);
+                }
             }
         }
         walk_list!(self, visit_generic_param, &generics.params);
@@ -1546,6 +1548,9 @@ fn deny_equality_constraints(
         predicate.span,
         "equality constraints are not yet supported in `where` clauses",
     );
+    if this.session.is_nightly_build() {
+        err.help("add `#![feature(type_equality_constraints)]` to the crate attributes to enable");
+    }
     err.span_label(predicate.span, "not supported");
 
     // Given `<A as Foo>::Bar = RhsTy`, suggest `A: Foo<Bar = RhsTy>`.

compiler/rustc_feature/src/active.rs

@@ -680,6 +680,9 @@ declare_features! (
     /// Allows `#[derive(Default)]` and `#[default]` on enums.
     (active, derive_default_enum, "1.56.0", Some(86985), None),
 
+    /// Allows `where T = U` in where predicates.
+    (active, type_equality_constraints, "1.56.0", Some(87533), None),
+
     // -------------------------------------------------------------------------
     // feature-group-end: actual feature gates
     // -------------------------------------------------------------------------

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

@@ -26,6 +26,7 @@ pub fn explicit_outlives_bounds<'tcx>(
             | ty::PredicateKind::TypeOutlives(..)
             | ty::PredicateKind::ConstEvaluatable(..)
             | ty::PredicateKind::ConstEquate(..)
+            | ty::PredicateKind::TypeEquate(..)
             | ty::PredicateKind::TypeWellFormedFromEnv(..) => None,
             ty::PredicateKind::RegionOutlives(ty::OutlivesPredicate(r_a, r_b)) => {
                 Some(OutlivesBound::RegionSubRegion(r_b, r_a))

compiler/rustc_infer/src/traits/util.rs

@@ -172,6 +172,10 @@ impl Elaborator<'tcx> {
                 // Currently, we do not elaborate const-equate
                 // predicates.
             }
+            ty::PredicateKind::TypeEquate(..) => {
+                // Currently, we do not elaborate type-equate
+                // predicates.
+            }
             ty::PredicateKind::RegionOutlives(..) => {
                 // Nothing to elaborate from `'a: 'b`.
             }

compiler/rustc_lint/src/builtin.rs

@@ -1612,6 +1612,7 @@ impl<'tcx> LateLintPass<'tcx> for TrivialConstraints {
                     Subtype(..) |
                     ConstEvaluatable(..) |
                     ConstEquate(..) |
+                    TypeEquate(..) |
                     TypeWellFormedFromEnv(..) => continue,
                 };
                 if predicate.is_global() {

compiler/rustc_middle/src/ty/flags.rs

@@ -252,6 +252,10 @@ impl FlagComputation {
             ty::PredicateKind::TypeWellFormedFromEnv(ty) => {
                 self.add_ty(ty);
             }
+            ty::PredicateKind::TypeEquate(lhs, rhs) => {
+                self.add_ty(lhs);
+                self.add_ty(rhs);
+            }
         }
     }
 

compiler/rustc_middle/src/ty/mod.rs

@@ -492,6 +492,9 @@ pub enum PredicateKind<'tcx> {
     ///
     /// Only used for Chalk.
     TypeWellFormedFromEnv(Ty<'tcx>),
+
+    /// `where T = U`
+    TypeEquate(Ty<'tcx>, Ty<'tcx>),
 }
 
 /// The crate outlives map is computed during typeck and contains the
@@ -800,6 +803,7 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::TypeOutlives(..)
             | PredicateKind::ConstEvaluatable(..)
             | PredicateKind::ConstEquate(..)
+            | PredicateKind::TypeEquate(..)
             | PredicateKind::TypeWellFormedFromEnv(..) => None,
         }
     }
@@ -817,6 +821,7 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::ClosureKind(..)
             | PredicateKind::ConstEvaluatable(..)
             | PredicateKind::ConstEquate(..)
+            | PredicateKind::TypeEquate(..)
             | PredicateKind::TypeWellFormedFromEnv(..) => None,
         }
     }

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -2292,6 +2292,9 @@ define_print_and_forward_display! {
             ty::PredicateKind::TypeWellFormedFromEnv(ty) => {
                 p!("the type `", print(ty), "` is found in the environment")
             }
+            ty::PredicateKind::TypeEquate(lhs, rhs) => {
+                p!("the type `", print(lhs), "` equals `", print(rhs), "`")
+            }
         }
     }
 

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -198,6 +198,9 @@ impl fmt::Debug for ty::PredicateKind<'tcx> {
             ty::PredicateKind::TypeWellFormedFromEnv(ty) => {
                 write!(f, "TypeWellFormedFromEnv({:?})", ty)
             }
+            ty::PredicateKind::TypeEquate(lhs, rhs) => {
+                write!(f, "TypeEquate({:?}, {:?})", lhs, rhs)
+            }
         }
     }
 }
@@ -450,6 +453,9 @@ impl<'a, 'tcx> Lift<'tcx> for ty::PredicateKind<'a> {
             ty::PredicateKind::TypeWellFormedFromEnv(ty) => {
                 tcx.lift(ty).map(ty::PredicateKind::TypeWellFormedFromEnv)
             }
+            ty::PredicateKind::TypeEquate(lhs, rhs) => {
+                tcx.lift((lhs, rhs)).map(|(lhs, rhs)| ty::PredicateKind::TypeEquate(lhs, rhs))
+            }
         }
     }
 }

compiler/rustc_mir/src/transform/check_consts/check.rs

@@ -413,6 +413,7 @@ impl Checker<'mir, 'tcx> {
                     | ty::PredicateKind::Projection(_)
                     | ty::PredicateKind::ConstEvaluatable(..)
                     | ty::PredicateKind::ConstEquate(..)
+                    | ty::PredicateKind::TypeEquate(..)
                     | ty::PredicateKind::TypeWellFormedFromEnv(..) => continue,
                     ty::PredicateKind::ObjectSafe(_) => {
                         bug!("object safe predicate on function: {:#?}", predicate)