Binders have predicates now

Author: compiler-errors

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -707,7 +707,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         self_ty: Ty<'tcx>,
         bounds: &mut Bounds<'tcx>,
         speculative: bool,
-        _binder_predicates: &'tcx ty::List<ty::Clause<'tcx>>,
+        binder_predicates: &'tcx ty::List<ty::Clause<'tcx>>,
         only_self_bounds: OnlySelfBounds,
     ) -> GenericArgCountResult {
         let trait_def_id = trait_ref.trait_def_id().unwrap_or_else(|| FatalError.raise());
@@ -734,9 +734,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
         let assoc_bindings = self.create_assoc_bindings_for_generic_args(args);
 
-        let poly_trait_ref = ty::Binder::bind_with_vars(
+        let poly_trait_ref = ty::Binder::bind_with_vars_and_predicates(
             ty::TraitRef::new(tcx, trait_def_id, generic_args),
             bound_vars,
+            binder_predicates,
         );
 
         debug!(?poly_trait_ref, ?assoc_bindings);

compiler/rustc_infer/src/infer/mod.rs

@@ -1470,6 +1470,8 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         T: TypeFoldable<TyCtxt<'tcx>> + Copy,
     {
+        assert_eq!(value.skip_binder_predicates(), ty::List::empty());
+
         if let Some(inner) = value.no_bound_vars() {
             return inner;
         }

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

@@ -74,6 +74,8 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         T: TypeFoldable<TyCtxt<'tcx>> + Copy,
     {
+        assert_eq!(binder.skip_binder_predicates(), ty::List::empty());
+
         if let Some(inner) = binder.no_bound_vars() {
             return inner;
         }

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

@@ -266,6 +266,8 @@ where
     where
         T: ty::TypeFoldable<TyCtxt<'tcx>> + Copy,
     {
+        assert_eq!(binder.skip_binder_predicates(), ty::List::empty());
+
         if let Some(inner) = binder.no_bound_vars() {
             return inner;
         }
@@ -314,6 +316,8 @@ where
     where
         T: ty::TypeFoldable<TyCtxt<'tcx>> + Copy,
     {
+        assert_eq!(binder.skip_binder_predicates(), ty::List::empty());
+
         if let Some(inner) = binder.no_bound_vars() {
             return inner;
         }

compiler/rustc_middle/src/ty/context.rs

@@ -1384,6 +1384,7 @@ nop_lift! {predicate; Clause<'a> => Clause<'tcx>}
 nop_list_lift! {type_lists; Ty<'a> => Ty<'tcx>}
 nop_list_lift! {poly_existential_predicates; PolyExistentialPredicate<'a> => PolyExistentialPredicate<'tcx>}
 nop_list_lift! {bound_variable_kinds; ty::BoundVariableKind => ty::BoundVariableKind}
+nop_list_lift! {clauses; Clause<'a> => Clause<'tcx>}
 
 // This is the impl for `&'a GenericArgs<'a>`.
 nop_list_lift! {args; GenericArg<'a> => GenericArg<'tcx>}

compiler/rustc_middle/src/ty/mod.rs

@@ -234,8 +234,8 @@ pub enum ImplSubject<'tcx> {
     Inherent(Ty<'tcx>),
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable, Debug)]
-#[derive(TypeFoldable, TypeVisitable)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
+#[derive(HashStable, TypeFoldable, TypeVisitable, TyEncodable, TyDecodable)]
 pub enum ImplPolarity {
     /// `impl Trait for Type`
     Positive,
@@ -491,7 +491,7 @@ impl EarlyParamRegion {
 /// predicate which is emitted when a type is coerced to a trait object.
 ///
 /// Use this rather than `PredicateKind`, whenever possible.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, HashStable)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable)]
 #[rustc_pass_by_value]
 pub struct Predicate<'tcx>(
     Interned<'tcx, WithCachedTypeInfo<ty::Binder<'tcx, PredicateKind<'tcx>>>>,
@@ -591,7 +591,7 @@ impl rustc_errors::IntoDiagnosticArg for Clause<'_> {
 /// A subset of predicates which can be assumed by the trait solver. They show up in
 /// an item's where clauses, hence the name `Clause`, and may either be user-written
 /// (such as traits) or may be inserted during lowering.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, HashStable)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, HashStable, PartialOrd, Ord)]
 #[rustc_pass_by_value]
 pub struct Clause<'tcx>(Interned<'tcx, WithCachedTypeInfo<ty::Binder<'tcx, PredicateKind<'tcx>>>>);
 
@@ -764,8 +764,8 @@ impl<'tcx> Clause<'tcx> {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
-#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(HashStable, TypeFoldable, TypeVisitable, Lift, TyEncodable, TyDecodable)]
 pub struct TraitPredicate<'tcx> {
     pub trait_ref: TraitRef<'tcx>,
 
@@ -823,8 +823,8 @@ pub type PolyTypeOutlivesPredicate<'tcx> = ty::Binder<'tcx, TypeOutlivesPredicat
 /// Encodes that `a` must be a subtype of `b`. The `a_is_expected` flag indicates
 /// whether the `a` type is the type that we should label as "expected" when
 /// presenting user diagnostics.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable)]
-#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
+#[derive(HashStable, TypeFoldable, TypeVisitable, Lift, TyEncodable, TyDecodable)]
 pub struct SubtypePredicate<'tcx> {
     pub a_is_expected: bool,
     pub a: Ty<'tcx>,
@@ -833,8 +833,8 @@ pub struct SubtypePredicate<'tcx> {
 pub type PolySubtypePredicate<'tcx> = ty::Binder<'tcx, SubtypePredicate<'tcx>>;
 
 /// Encodes that we have to coerce *from* the `a` type to the `b` type.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable)]
-#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
+#[derive(HashStable, TypeFoldable, TypeVisitable, Lift, TyEncodable, TyDecodable)]
 pub struct CoercePredicate<'tcx> {
     pub a: Ty<'tcx>,
     pub b: Ty<'tcx>,
@@ -1039,8 +1039,8 @@ impl From<ty::ConstVid> for TermVid {
 /// equality between arbitrary types. Processing an instance of
 /// Form #2 eventually yields one of these `ProjectionPredicate`
 /// instances to normalize the LHS.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
-#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(HashStable, TypeFoldable, TypeVisitable, Lift, TyEncodable, TyDecodable)]
 pub struct ProjectionPredicate<'tcx> {
     pub projection_ty: AliasTy<'tcx>,
     pub term: Term<'tcx>,
@@ -1102,8 +1102,8 @@ impl<'tcx> PolyProjectionPredicate<'tcx> {
 
 /// Used by the new solver. Unlike a `ProjectionPredicate` this can only be
 /// proven by actually normalizing `alias`.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
-#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable, Lift)]
 pub struct NormalizesTo<'tcx> {
     pub alias: AliasTy<'tcx>,
     pub term: Term<'tcx>,

compiler/rustc_middle/src/ty/sty.rs

@@ -991,6 +991,7 @@ impl BoundVariableKind {
 pub struct Binder<'tcx, T> {
     value: T,
     bound_vars: &'tcx List<BoundVariableKind>,
+    bound_predicates: &'tcx List<ty::Clause<'tcx>>,
 }
 
 impl<'tcx, T> Binder<'tcx, T>
@@ -1007,19 +1008,36 @@ where
             !value.has_escaping_bound_vars(),
             "`{value:?}` has escaping bound vars, so it cannot be wrapped in a dummy binder."
         );
-        Binder { value, bound_vars: ty::List::empty() }
+        Binder { value, bound_vars: ty::List::empty(), bound_predicates: ty::List::empty() }
     }
 
     pub fn bind_with_vars(value: T, bound_vars: &'tcx List<BoundVariableKind>) -> Binder<'tcx, T> {
         if cfg!(debug_assertions) {
             let mut validator = ValidateBoundVars::new(bound_vars);
             value.visit_with(&mut validator);
         }
-        Binder { value, bound_vars }
+        Binder { value, bound_vars, bound_predicates: ty::List::empty() }
+    }
+
+    pub fn bind_with_vars_and_predicates(
+        value: T,
+        bound_vars: &'tcx List<BoundVariableKind>,
+        bound_predicates: &'tcx List<ty::Clause<'tcx>>,
+    ) -> Binder<'tcx, T> {
+        if cfg!(debug_assertions) {
+            let mut validator = ValidateBoundVars::new(bound_vars);
+            value.visit_with(&mut validator);
+            bound_predicates.visit_with(&mut validator);
+        }
+        Binder { value, bound_vars, bound_predicates }
     }
 }
 
 impl<'tcx, T> Binder<'tcx, T> {
+    pub fn skip_binder_predicates(self) -> &'tcx List<ty::Clause<'tcx>> {
+        self.bound_predicates
+    }
+
     /// Skips the binder and returns the "bound" value. This is a
     /// risky thing to do because it's easy to get confused about
     /// De Bruijn indices and the like. It is usually better to
@@ -1045,22 +1063,30 @@ impl<'tcx, T> Binder<'tcx, T> {
     }
 
     pub fn as_ref(&self) -> Binder<'tcx, &T> {
-        Binder { value: &self.value, bound_vars: self.bound_vars }
+        Binder {
+            value: &self.value,
+            bound_vars: self.bound_vars,
+            bound_predicates: self.bound_predicates,
+        }
     }
 
     pub fn as_deref(&self) -> Binder<'tcx, &T::Target>
     where
         T: Deref,
     {
-        Binder { value: &self.value, bound_vars: self.bound_vars }
+        Binder {
+            value: &self.value,
+            bound_vars: self.bound_vars,
+            bound_predicates: self.bound_predicates,
+        }
     }
 
     pub fn map_bound_ref_unchecked<F, U>(&self, f: F) -> Binder<'tcx, U>
     where
         F: FnOnce(&T) -> U,
     {
         let value = f(&self.value);
-        Binder { value, bound_vars: self.bound_vars }
+        Binder { value, bound_vars: self.bound_vars, bound_predicates: self.bound_predicates }
     }
 
     pub fn map_bound_ref<F, U: TypeVisitable<TyCtxt<'tcx>>>(&self, f: F) -> Binder<'tcx, U>
@@ -1074,13 +1100,13 @@ impl<'tcx, T> Binder<'tcx, T> {
     where
         F: FnOnce(T) -> U,
     {
-        let Binder { value, bound_vars } = self;
+        let Binder { value, bound_vars, bound_predicates } = self;
         let value = f(value);
         if cfg!(debug_assertions) {
             let mut validator = ValidateBoundVars::new(bound_vars);
             value.visit_with(&mut validator);
         }
-        Binder { value, bound_vars }
+        Binder { value, bound_vars, bound_predicates }
     }
 
     pub fn try_map_bound<F, U: TypeVisitable<TyCtxt<'tcx>>, E>(
@@ -1090,13 +1116,13 @@ impl<'tcx, T> Binder<'tcx, T> {
     where
         F: FnOnce(T) -> Result<U, E>,
     {
-        let Binder { value, bound_vars } = self;
+        let Binder { value, bound_vars, bound_predicates } = self;
         let value = f(value)?;
         if cfg!(debug_assertions) {
             let mut validator = ValidateBoundVars::new(bound_vars);
             value.visit_with(&mut validator);
         }
-        Ok(Binder { value, bound_vars })
+        Ok(Binder { value, bound_vars, bound_predicates })
     }
 
     /// Wraps a `value` in a binder, using the same bound variables as the
@@ -1112,7 +1138,7 @@ impl<'tcx, T> Binder<'tcx, T> {
     where
         U: TypeVisitable<TyCtxt<'tcx>>,
     {
-        Binder::bind_with_vars(value, self.bound_vars)
+        Binder::bind_with_vars_and_predicates(value, self.bound_vars, self.bound_predicates)
     }
 
     /// Unwraps and returns the value within, but only if it contains
@@ -1142,23 +1168,26 @@ impl<'tcx, T> Binder<'tcx, T> {
     where
         F: FnOnce(T) -> (U, V),
     {
-        let Binder { value, bound_vars } = self;
+        let Binder { value, bound_vars, bound_predicates } = self;
         let (u, v) = f(value);
-        (Binder { value: u, bound_vars }, Binder { value: v, bound_vars })
+        (
+            Binder { value: u, bound_vars, bound_predicates },
+            Binder { value: v, bound_vars, bound_predicates },
+        )
     }
 }
 
 impl<'tcx, T> Binder<'tcx, Option<T>> {
     pub fn transpose(self) -> Option<Binder<'tcx, T>> {
-        let Binder { value, bound_vars } = self;
-        value.map(|value| Binder { value, bound_vars })
+        let Binder { value, bound_vars, bound_predicates } = self;
+        value.map(|value| Binder { value, bound_vars, bound_predicates })
     }
 }
 
 impl<'tcx, T: IntoIterator> Binder<'tcx, T> {
     pub fn iter(self) -> impl Iterator<Item = ty::Binder<'tcx, T::Item>> {
-        let Binder { value, bound_vars } = self;
-        value.into_iter().map(|value| Binder { value, bound_vars })
+        let Binder { value, bound_vars, bound_predicates } = self;
+        value.into_iter().map(|value| Binder { value, bound_vars, bound_predicates })
     }
 }
 

compiler/rustc_type_ir/src/interner.rs

@@ -70,15 +70,15 @@ pub trait Interner: Sized {
     type PlaceholderRegion: Copy + Debug + Hash + Ord + PlaceholderLike;
 
     // Predicates
-    type Predicate: Copy + Debug + Hash + Eq;
-    type TraitPredicate: Copy + Debug + Hash + Eq;
-    type RegionOutlivesPredicate: Copy + Debug + Hash + Eq;
-    type TypeOutlivesPredicate: Copy + Debug + Hash + Eq;
-    type ProjectionPredicate: Copy + Debug + Hash + Eq;
-    type NormalizesTo: Copy + Debug + Hash + Eq;
-    type SubtypePredicate: Copy + Debug + Hash + Eq;
-    type CoercePredicate: Copy + Debug + Hash + Eq;
-    type ClosureKind: Copy + Debug + Hash + Eq;
+    type Predicate: Copy + Debug + Hash + Ord;
+    type TraitPredicate: Copy + Debug + Hash + Ord;
+    type RegionOutlivesPredicate: Copy + Debug + Hash + Ord;
+    type TypeOutlivesPredicate: Copy + Debug + Hash + Ord;
+    type ProjectionPredicate: Copy + Debug + Hash + Ord;
+    type NormalizesTo: Copy + Debug + Hash + Ord;
+    type SubtypePredicate: Copy + Debug + Hash + Ord;
+    type CoercePredicate: Copy + Debug + Hash + Ord;
+    type ClosureKind: Copy + Debug + Hash + Ord;
 
     fn mk_canonical_var_infos(self, infos: &[CanonicalVarInfo<Self>]) -> Self::CanonicalVars;
 

compiler/rustc_type_ir/src/predicate_kind.rs

@@ -8,7 +8,15 @@ use crate::Interner;
 /// A clause is something that can appear in where bounds or be inferred
 /// by implied bounds.
 #[derive(derivative::Derivative)]
-#[derivative(Clone(bound = ""), Copy(bound = ""), Hash(bound = ""))]
+#[derivative(
+    Clone(bound = ""),
+    Copy(bound = ""),
+    Hash(bound = ""),
+    PartialOrd(bound = ""),
+    PartialOrd = "feature_allow_slow_enum",
+    Ord(bound = ""),
+    Ord = "feature_allow_slow_enum"
+)]
 #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
 pub enum ClauseKind<I: Interner> {
     /// Corresponds to `where Foo: Bar<A, B, C>`. `Foo` here would be
@@ -113,7 +121,11 @@ where
     Copy(bound = ""),
     Hash(bound = ""),
     PartialEq(bound = ""),
-    Eq(bound = "")
+    Eq(bound = ""),
+    PartialOrd(bound = ""),
+    PartialOrd = "feature_allow_slow_enum",
+    Ord(bound = ""),
+    Ord = "feature_allow_slow_enum"
 )]
 #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
 pub enum PredicateKind<I: Interner> {