Support trait predicates on poly trait refs

Author: compiler-errors

Diff for: compiler/rustc_ast_lowering/src/lib.rs

@@ -2011,6 +2011,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         hir::GenericBound::Trait(
             hir::PolyTraitRef {
                 bound_generic_params: &[],
+                binder_predicates: &[],
                 trait_ref: hir::TraitRef {
                     path: self.make_lang_item_path(
                         trait_lang_item,
@@ -2201,10 +2202,28 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         itctx: &ImplTraitContext,
         constness: ast::Const,
     ) -> hir::PolyTraitRef<'hir> {
+        let binder_predicates =
+            self.arena.alloc_from_iter(p.bound_generic_params.iter().filter_map(|param| {
+                self.lower_generic_bound_predicate(
+                    param.ident,
+                    param.id,
+                    &param.kind,
+                    &param.bounds,
+                    param.colon_span,
+                    p.span,
+                    &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                    hir::PredicateOrigin::GenericParam,
+                )
+            }));
         let bound_generic_params =
             self.lower_lifetime_binder(p.trait_ref.ref_id, &p.bound_generic_params);
         let trait_ref = self.lower_trait_ref(constness, &p.trait_ref, itctx);
-        hir::PolyTraitRef { bound_generic_params, trait_ref, span: self.lower_span(p.span) }
+        hir::PolyTraitRef {
+            bound_generic_params,
+            binder_predicates,
+            trait_ref,
+            span: self.lower_span(p.span),
+        }
     }
 
     fn lower_mt(&mut self, mt: &MutTy, itctx: &ImplTraitContext) -> hir::MutTy<'hir> {
@@ -2510,6 +2529,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     Res::Def(DefKind::Trait | DefKind::TraitAlias, _) => {
                         let principal = hir::PolyTraitRef {
                             bound_generic_params: &[],
+                            binder_predicates: &[],
                             trait_ref: hir::TraitRef { path, hir_ref_id: hir_id },
                             span: self.lower_span(span),
                         };

Diff for: compiler/rustc_hir/src/hir.rs

@@ -2822,6 +2822,9 @@ pub struct PolyTraitRef<'hir> {
     /// The `'a` in `for<'a> Foo<&'a T>`.
     pub bound_generic_params: &'hir [GenericParam<'hir>],
 
+    /// Predicates on the `for<T>` binder itself, such as `for<T: Trait> ...`
+    pub binder_predicates: &'hir [WherePredicate<'hir>],
+
     /// The `Foo<&'a T>` in `for<'a> Foo<&'a T>`.
     pub trait_ref: TraitRef<'hir>,
 

Diff for: compiler/rustc_hir/src/intravisit.rs

@@ -1084,6 +1084,7 @@ pub fn walk_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, bound: &'v GenericB
 pub fn walk_poly_trait_ref<'v, V: Visitor<'v>>(visitor: &mut V, trait_ref: &'v PolyTraitRef<'v>) {
     walk_list!(visitor, visit_generic_param, trait_ref.bound_generic_params);
     visitor.visit_trait_ref(&trait_ref.trait_ref);
+    walk_list!(visitor, visit_where_predicate, trait_ref.binder_predicates);
 }
 
 pub fn walk_struct_def<'v, V: Visitor<'v>>(

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

@@ -18,8 +18,8 @@ use crate::errors;
 impl<'tcx> dyn AstConv<'tcx> + '_ {
     pub(crate) fn lower_where_predicates(
         &self,
-        params: &'tcx [hir::GenericParam<'tcx>],
-        hir_predicates: &'tcx [hir::WherePredicate<'tcx>],
+        params: &[hir::GenericParam<'_>],
+        hir_predicates: &[hir::WherePredicate<'_>],
         predicates: &mut FxIndexSet<(ty::Clause<'tcx>, Span)>,
     ) {
         // Collect the predicates that were written inline by the user on each
@@ -140,19 +140,19 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
     }
 
     /// Sets `implicitly_sized` to true on `Bounds` if necessary
-    pub(crate) fn add_implicitly_sized(
+    pub(crate) fn add_implicitly_sized<'hir>(
         &self,
         bounds: &mut Bounds<'tcx>,
         self_ty: Ty<'tcx>,
-        ast_bounds: &'tcx [hir::GenericBound<'tcx>],
-        self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
+        ast_bounds: &'hir [hir::GenericBound<'hir>],
+        self_ty_where_predicates: Option<(LocalDefId, &'hir [hir::WherePredicate<'hir>])>,
         span: Span,
     ) {
         let tcx = self.tcx();
 
         // Try to find an unbound in bounds.
         let mut unbounds: SmallVec<[_; 1]> = SmallVec::new();
-        let mut search_bounds = |ast_bounds: &'tcx [hir::GenericBound<'tcx>]| {
+        let mut search_bounds = |ast_bounds: &'hir [hir::GenericBound<'hir>]| {
             for ab in ast_bounds {
                 if let hir::GenericBound::Trait(ptr, hir::TraitBoundModifier::Maybe) = ab {
                     unbounds.push(ptr);
@@ -248,8 +248,16 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                         hir::TraitBoundModifier::Maybe => continue,
                     };
 
-                    // TODO: Add in the binder preds from the poly trait ref.
-                    let binder_predicates = binder_predicates;
+                    let mut additional_binder_predicates = FxIndexSet::default();
+                    self.lower_where_predicates(
+                        poly_trait_ref.bound_generic_params,
+                        poly_trait_ref.binder_predicates,
+                        &mut additional_binder_predicates,
+                    );
+                    let binder_predicates =
+                        self.tcx().mk_clauses_from_iter(binder_predicates.into_iter().chain(
+                            additional_binder_predicates.into_iter().map(|(clause, _)| clause),
+                        ));
 
                     let _ = self.instantiate_poly_trait_ref(
                         &poly_trait_ref.trait_ref,

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

@@ -33,6 +33,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         let mut potential_assoc_types = Vec::new();
         let dummy_self = self.tcx().types.trait_object_dummy_self;
         for trait_bound in hir_trait_bounds.iter().rev() {
+            assert!(
+                trait_bound.binder_predicates.is_empty(),
+                "FIXME(non_lifetime_binders): object types should not have binders"
+            );
             if let GenericArgCountResult {
                 correct:
                     Err(GenericArgCountMismatch { invalid_args: cur_potential_assoc_types, .. }),
@@ -45,7 +49,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 dummy_self,
                 &mut bounds,
                 false,
-                // TODO: dyn traits should have no binder preds
                 ty::List::empty(),
                 // FIXME: This should be `true`, but we don't really handle
                 // associated type bounds or type aliases in objects in a way

Diff for: compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -712,6 +712,16 @@ impl<'tcx> ItemCtxt<'tcx> {
                 }
             };
 
+            let mut binder_predicates = FxIndexSet::default();
+            self.astconv().lower_where_predicates(
+                predicate.bound_generic_params,
+                predicate.binder_predicates,
+                &mut binder_predicates,
+            );
+            let binder_predicates = self
+                .tcx
+                .mk_clauses_from_iter(binder_predicates.into_iter().map(|(clause, _)| clause));
+
             // Subtle: If we're collecting `SelfAndAssociatedTypeBounds`, then we
             // want to only consider predicates with `Self: ...`, but we don't want
             // `OnlySelfBounds(true)` since we want to collect the nested associated
@@ -733,8 +743,7 @@ impl<'tcx> ItemCtxt<'tcx> {
                 }),
                 &mut bounds,
                 bound_vars,
-                // TODO: convert `where_bound_predicate` above accordingly
-                ty::List::empty(),
+                binder_predicates,
                 only_self_bounds,
             );
         }

Diff for: compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -398,6 +398,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
         self.with(scope, |this| {
             walk_list!(this, visit_generic_param, trait_ref.bound_generic_params);
             this.visit_trait_ref(&trait_ref.trait_ref);
+            walk_list!(this, visit_where_predicate, trait_ref.binder_predicates);
         });
     }
 }

Diff for: compiler/rustc_hir_analysis/src/lib.rs

@@ -267,7 +267,7 @@ pub fn hir_trait_to_predicates<'tcx>(
         self_ty,
         &mut bounds,
         true,
-        // TODO: This is probably wrong!
+        // FIXME(non_lifetime_binders): This is probably not right.
         ty::List::empty(),
         OnlySelfBounds(false),
     );

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

@@ -747,18 +747,28 @@ impl<'tcx> Clause<'tcx> {
         let pred_bound_vars = bound_pred.bound_vars();
         let trait_bound_vars = trait_ref.bound_vars();
         // 1) Self: Bar1<'a, '^0.0> -> Self: Bar1<'a, '^0.1>
-        let shifted_pred =
-            tcx.shift_bound_var_indices(trait_bound_vars.len(), bound_pred.skip_binder());
+        let (shifted_pred, shifted_bound_clauses) = tcx.shift_bound_var_indices(
+            trait_bound_vars.len(),
+            (bound_pred.skip_binder(), bound_pred.skip_binder_predicates()),
+        );
         // 2) Self: Bar1<'a, '^0.1> -> T: Bar1<'^0.0, '^0.1>
         let new = EarlyBinder::bind(shifted_pred).instantiate(tcx, trait_ref.skip_binder().args);
         // 3) ['x] + ['b] -> ['x, 'b]
         let bound_vars =
             tcx.mk_bound_variable_kinds_from_iter(trait_bound_vars.iter().chain(pred_bound_vars));
 
+        let binder_predicates = tcx.mk_clauses_from_iter(
+            trait_ref.skip_binder_predicates().into_iter().chain(shifted_bound_clauses),
+        );
+
         // FIXME: Is it really perf sensitive to use reuse_or_mk_predicate here?
         tcx.reuse_or_mk_predicate(
             self.as_predicate(),
-            ty::Binder::bind_with_vars(PredicateKind::Clause(new), bound_vars),
+            ty::Binder::bind_with_vars_and_predicates(
+                PredicateKind::Clause(new),
+                bound_vars,
+                binder_predicates,
+            ),
         )
         .expect_clause()
     }