Binders have predicates now

Author: compiler-errors

Diff for: compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -687,7 +687,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         args: &GenericArgs<'_>,
         infer_args: bool,
         self_ty: Ty<'tcx>,
-        _binder_predicates: &'tcx ty::List<ty::Clause<'tcx>>,
+        binder_predicates: &'tcx ty::List<ty::Clause<'tcx>>,
         only_self_bounds: OnlySelfBounds,
     ) -> GenericArgCountResult {
         let (generic_args, arg_count) = self.create_args_for_ast_path(
@@ -707,9 +707,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);

Diff for: compiler/rustc_infer/src/infer/higher_ranked/mod.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;
         }

Diff for: compiler/rustc_infer/src/infer/mod.rs

@@ -1446,6 +1446,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;
         }

Diff for: compiler/rustc_infer/src/infer/nll_relate/mod.rs

@@ -263,6 +263,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;
         }
@@ -311,6 +313,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;
         }

Diff for: compiler/rustc_middle/src/ty/mod.rs

@@ -244,8 +244,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,
@@ -573,7 +573,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>>>>);
 
@@ -626,8 +626,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)]
 /// A clause is something that can appear in where bounds or be inferred
 /// by implied bounds.
 pub enum ClauseKind<'tcx> {
@@ -657,8 +657,8 @@ pub enum ClauseKind<'tcx> {
     ConstEvaluatable(ty::Const<'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 enum PredicateKind<'tcx> {
     /// Prove a clause
     Clause(ClauseKind<'tcx>),
@@ -702,8 +702,8 @@ pub enum PredicateKind<'tcx> {
     AliasRelate(Term<'tcx>, Term<'tcx>, AliasRelationDirection),
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
-#[derive(HashStable, Debug)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(HashStable, Debug, TyEncodable, TyDecodable)]
 pub enum AliasRelationDirection {
     Equate,
     Subtype,
@@ -838,8 +838,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>,
 
@@ -897,8 +897,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>,
@@ -907,8 +907,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>,
@@ -1113,8 +1113,8 @@ impl<'tcx> From<ty::ConstVid<'tcx>> for TermVid<'tcx> {
 /// 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>,

Diff for: compiler/rustc_middle/src/ty/sty.rs

@@ -1000,6 +1000,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>
@@ -1016,19 +1017,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
@@ -1054,22 +1072,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>
@@ -1083,13 +1109,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>(
@@ -1099,13 +1125,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
@@ -1121,7 +1147,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
@@ -1151,23 +1177,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 })
     }
 }