More non-lifetime binder stuff

Author: compiler-errors

compiler/rustc_ast_lowering/src/item.rs

@@ -1577,6 +1577,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     bounds,
                     span,
                     bound_generic_params: &[],
+                    binder_predicates: &[],
                     origin,
                 }))
             }
@@ -1605,6 +1606,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 hir_id: self.next_id(),
                 bound_generic_params: self
                     .lower_generic_params(bound_generic_params, hir::GenericParamSource::Binder),
+                binder_predicates: self.arena.alloc_from_iter(
+                    bound_generic_params.iter().filter_map(|param| {
+                        self.lower_generic_bound_predicate(
+                            param.ident,
+                            param.id,
+                            &param.kind,
+                            &param.bounds,
+                            param.colon_span,
+                            *span,
+                            &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                            PredicateOrigin::GenericParam,
+                        )
+                    }),
+                ),
                 bounded_ty: self
                     .lower_ty(bounded_ty, &ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
                 bounds: self.lower_param_bounds(

compiler/rustc_hir/src/hir.rs

@@ -756,9 +756,11 @@ pub struct WhereBoundPredicate<'hir> {
     pub origin: PredicateOrigin,
     /// Any generics from a `for` binding.
     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 type being bounded.
     pub bounded_ty: &'hir Ty<'hir>,
-    /// Trait and lifetime bounds (e.g., `Clone + Send + 'static`).
+    /// Trait and lifetime bounds for `bounded_ty` (e.g., `Clone + Send + 'static`).
     pub bounds: GenericBounds<'hir>,
 }
 

compiler/rustc_hir/src/intravisit.rs

@@ -904,11 +904,13 @@ pub fn walk_where_predicate<'v, V: Visitor<'v>>(
             bound_generic_params,
             origin: _,
             span: _,
+            binder_predicates,
         }) => {
             visitor.visit_id(hir_id);
             visitor.visit_ty(bounded_ty);
             walk_list!(visitor, visit_param_bound, bounds);
             walk_list!(visitor, visit_generic_param, bound_generic_params);
+            walk_list!(visitor, visit_where_predicate, binder_predicates);
         }
         WherePredicate::RegionPredicate(WhereRegionPredicate {
             ref lifetime,

compiler/rustc_hir_analysis/src/astconv/bounds.rs

@@ -1,9 +1,9 @@
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
 use rustc_errors::struct_span_err;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_middle::ty::{self as ty, Ty};
+use rustc_middle::ty::{self as ty, ToPredicate, Ty};
 use rustc_span::symbol::Ident;
 use rustc_span::{ErrorGuaranteed, Span};
 use rustc_trait_selection::traits;
@@ -16,6 +16,132 @@ use crate::bounds::Bounds;
 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>],
+        predicates: &mut FxIndexSet<(ty::Clause<'tcx>, Span)>,
+    ) {
+        // Collect the predicates that were written inline by the user on each
+        // type parameter (e.g., `<T: Foo>`). Also add `ConstArgHasType` predicates
+        // for each const parameter.
+        for param in params {
+            match param.kind {
+                hir::GenericParamKind::Lifetime { .. } => (),
+                hir::GenericParamKind::Type { .. } => {
+                    let param_ty =
+                        ty::fold::shift_vars(self.tcx(), self.hir_id_to_bound_ty(param.hir_id), 1);
+                    let mut bounds = Bounds::default();
+                    // Params are implicitly sized unless a `?Sized` bound is found
+                    self.add_implicitly_sized(
+                        &mut bounds,
+                        param_ty,
+                        &[],
+                        Some((param.def_id, hir_predicates)),
+                        param.span,
+                    );
+                    trace!(?bounds);
+                    predicates.extend(bounds.clauses());
+                    trace!(?predicates);
+                }
+                hir::GenericParamKind::Const { .. } => {
+                    let ct_ty = self
+                        .tcx()
+                        .type_of(param.def_id.to_def_id())
+                        .no_bound_vars()
+                        .expect("const parameters cannot be generic");
+                    let ct = ty::fold::shift_vars(
+                        self.tcx(),
+                        self.hir_id_to_bound_const(param.hir_id, ct_ty),
+                        1,
+                    );
+                    predicates.insert((
+                        ty::Binder::bind_with_vars(
+                            ty::ClauseKind::ConstArgHasType(ct, ct_ty),
+                            ty::List::empty(),
+                        )
+                        .to_predicate(self.tcx()),
+                        param.span,
+                    ));
+                }
+            }
+        }
+
+        // Add in the bounds that appear in the where-clause.
+        for predicate in hir_predicates {
+            match predicate {
+                hir::WherePredicate::BoundPredicate(bound_pred) => {
+                    let ty = self.ast_ty_to_ty(bound_pred.bounded_ty);
+                    let bound_vars = self.tcx().late_bound_vars(bound_pred.hir_id);
+
+                    let mut binder_predicates = FxIndexSet::default();
+                    self.lower_where_predicates(
+                        bound_pred.bound_generic_params,
+                        bound_pred.binder_predicates,
+                        &mut binder_predicates,
+                    );
+                    let binder_predicates = self.tcx().mk_clauses_from_iter(
+                        binder_predicates.into_iter().map(|(clause, _)| clause),
+                    );
+                    if !binder_predicates.is_empty() {
+                        println!("binder_predicates = {binder_predicates:#?}");
+                    }
+
+                    // Keep the type around in a dummy predicate, in case of no bounds.
+                    // That way, `where Ty:` is not a complete noop (see #53696) and `Ty`
+                    // is still checked for WF.
+                    if bound_pred.bounds.is_empty() {
+                        if let ty::Param(_) = ty.kind() {
+                            // This is a `where T:`, which can be in the HIR from the
+                            // transformation that moves `?Sized` to `T`'s declaration.
+                            // We can skip the predicate because type parameters are
+                            // trivially WF, but also we *should*, to avoid exposing
+                            // users who never wrote `where Type:,` themselves, to
+                            // compiler/tooling bugs from not handling WF predicates.
+                        } else {
+                            let span = bound_pred.bounded_ty.span;
+                            let predicate = ty::Binder::bind_with_vars(
+                                ty::ClauseKind::WellFormed(ty.into()),
+                                bound_vars,
+                            );
+                            predicates.insert((predicate.to_predicate(self.tcx()), span));
+                        }
+                    }
+
+                    let mut bounds = Bounds::default();
+                    self.add_bounds(
+                        ty,
+                        bound_pred.bounds.iter(),
+                        &mut bounds,
+                        bound_vars,
+                        binder_predicates,
+                        OnlySelfBounds(false),
+                    );
+                    predicates.extend(bounds.clauses());
+                }
+
+                hir::WherePredicate::RegionPredicate(region_pred) => {
+                    let r1 = self.ast_region_to_region(&region_pred.lifetime, None);
+                    predicates.extend(region_pred.bounds.iter().map(|bound| {
+                        let (r2, span) = match bound {
+                            hir::GenericBound::Outlives(lt) => {
+                                (self.ast_region_to_region(lt, None), lt.ident.span)
+                            }
+                            _ => bug!(),
+                        };
+                        let pred = ty::ClauseKind::RegionOutlives(ty::OutlivesPredicate(r1, r2))
+                            .to_predicate(self.tcx());
+                        (pred, span)
+                    }))
+                }
+
+                hir::WherePredicate::EqPredicate(..) => {
+                    // FIXME(#20041)
+                }
+            }
+        }
+    }
+
     /// Sets `implicitly_sized` to true on `Bounds` if necessary
     pub(crate) fn add_implicitly_sized(
         &self,
@@ -32,7 +158,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
         let mut search_bounds = |ast_bounds: &'tcx [hir::GenericBound<'tcx>]| {
             for ab in ast_bounds {
                 if let hir::GenericBound::Trait(ptr, hir::TraitBoundModifier::Maybe) = ab {
-                    unbounds.push(ptr)
+                    unbounds.push(ptr);
                 }
             }
         };
@@ -106,6 +232,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
         ast_bounds: I,
         bounds: &mut Bounds<'tcx>,
         bound_vars: &'tcx ty::List<ty::BoundVariableKind>,
+        binder_predicates: &'tcx ty::List<ty::Clause<'tcx>>,
         only_self_bounds: OnlySelfBounds,
     ) {
         for ast_bound in ast_bounds {
@@ -123,6 +250,10 @@ 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 _ = self.instantiate_poly_trait_ref(
                         &poly_trait_ref.trait_ref,
                         poly_trait_ref.span,
@@ -131,6 +262,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                         param_ty,
                         bounds,
                         false,
+                        binder_predicates,
                         only_self_bounds,
                     );
                 }
@@ -199,6 +331,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
             }),
             &mut bounds,
             ty::List::empty(),
+            ty::List::empty(),
             only_self_bounds,
         );
         debug!(?bounds);
@@ -503,6 +636,8 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                         ast_bounds.iter(),
                         bounds,
                         projection_ty.bound_vars(),
+                        // TODO: This is wrong, should take preds from binder
+                        ty::List::empty(),
                         only_self_bounds,
                     );
                 }

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -707,6 +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>>,
         only_self_bounds: OnlySelfBounds,
     ) -> GenericArgCountResult {
         let trait_def_id = trait_ref.trait_def_id().unwrap_or_else(|| FatalError.raise());

compiler/rustc_hir_analysis/src/astconv/object_safety.rs

@@ -45,6 +45,8 @@ 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
                 // that makes this meaningful, I think.

compiler/rustc_hir_analysis/src/bounds.rs

@@ -98,7 +98,10 @@ impl<'tcx> Bounds<'tcx> {
         let sized_def_id = tcx.require_lang_item(LangItem::Sized, Some(span));
         let trait_ref = ty::TraitRef::new(tcx, sized_def_id, [ty]);
         // Preferable to put this obligation first, since we report better errors for sized ambiguity.
-        self.clauses.insert(0, (trait_ref.to_predicate(tcx), span));
+        self.clauses.insert(
+            0,
+            (ty::Binder::bind_with_vars(trait_ref, ty::List::empty()).to_predicate(tcx), span),
+        );
     }
 
     pub fn clauses(&self) -> impl Iterator<Item = (ty::Clause<'tcx>, Span)> + '_ {