Auto merge of rust-lang#115362 - compiler-errors:non-lifetime-binder-where-clauses, r=<try>

[WIP] Support param bounds on non-lifetime binders

👀

r? `@ghost`

Author: bors

compiler/rustc_ast_lowering/src/item.rs

@@ -1753,6 +1753,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     bounded_ty: self.arena.alloc(bounded_ty),
                     bounds,
                     bound_generic_params: &[],
+                    bound_assumptions: &[],
                     origin,
                 })
             }
@@ -1782,6 +1783,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }) => hir::WherePredicateKind::BoundPredicate(hir::WhereBoundPredicate {
                 bound_generic_params: self
                     .lower_generic_params(bound_generic_params, hir::GenericParamSource::Binder),
+                bound_assumptions: 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::Bound),
+                            PredicateOrigin::GenericParam,
+                        )
+                    }),
+                ),
                 bounded_ty: self
                     .lower_ty(bounded_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
                 bounds: self.lower_param_bounds(

compiler/rustc_ast_lowering/src/lib.rs

@@ -55,7 +55,8 @@ use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle, StashKey};
 use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE, LocalDefId};
 use rustc_hir::{
-    self as hir, ConstArg, GenericArg, HirId, ItemLocalMap, LangItem, ParamName, TraitCandidate,
+    self as hir, ConstArg, GenericArg, HirId, ItemLocalMap, LangItem, ParamName, PredicateOrigin,
+    TraitCandidate,
 };
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
@@ -1734,6 +1735,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
         hir::GenericBound::Trait(hir::PolyTraitRef {
             bound_generic_params: &[],
+            bound_assumptions: &[],
             modifiers: hir::TraitBoundModifiers::NONE,
             trait_ref: hir::TraitRef {
                 path: self.make_lang_item_path(trait_lang_item, opaque_ty_span, Some(bound_args)),
@@ -1947,12 +1949,26 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         p: &PolyTraitRef,
         itctx: ImplTraitContext,
     ) -> hir::PolyTraitRef<'hir> {
+        let bound_assumptions =
+            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::Bound),
+                    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(p.modifiers, &p.trait_ref, itctx);
         let modifiers = self.lower_trait_bound_modifiers(p.modifiers);
         hir::PolyTraitRef {
             bound_generic_params,
+            bound_assumptions,
             modifiers,
             trait_ref,
             span: self.lower_span(p.span),
@@ -2361,6 +2377,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     Res::Def(DefKind::Trait | DefKind::TraitAlias, _) => {
                         let principal = hir::PolyTraitRef {
                             bound_generic_params: &[],
+                            bound_assumptions: &[],
                             modifiers: hir::TraitBoundModifiers::NONE,
                             trait_ref: hir::TraitRef { path, hir_ref_id: hir_id },
                             span: self.lower_span(span),

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -133,10 +133,12 @@ impl<'a> PostExpansionVisitor<'a> {
             }
         }
 
-        for param in params {
-            if !param.bounds.is_empty() {
-                let spans: Vec<_> = param.bounds.iter().map(|b| b.span()).collect();
-                self.sess.dcx().emit_err(errors::ForbiddenBound { spans });
+        if !self.features.non_lifetime_binders() {
+            for param in params {
+                if !param.bounds.is_empty() {
+                    let spans: Vec<_> = param.bounds.iter().map(|b| b.span()).collect();
+                    self.sess.dcx().emit_err(errors::ForbiddenBound { spans });
+                }
             }
         }
     }

compiler/rustc_hir/src/hir.rs

@@ -951,6 +951,8 @@ pub struct WhereBoundPredicate<'hir> {
     pub origin: PredicateOrigin,
     /// Any generics from a `for` binding.
     pub bound_generic_params: &'hir [GenericParam<'hir>],
+    /// The `'a + Trait` in `for<T: 'a + Trait> ...`
+    pub bound_assumptions: &'hir [WherePredicate<'hir>],
     /// The type being bounded.
     pub bounded_ty: &'hir Ty<'hir>,
     /// Trait and lifetime bounds (e.g., `Clone + Send + 'static`).
@@ -3793,6 +3795,9 @@ pub struct PolyTraitRef<'hir> {
     /// The `'a` in `for<'a> Foo<&'a T>`.
     pub bound_generic_params: &'hir [GenericParam<'hir>],
 
+    /// The `'a + Trait` in `for<T: 'a + Trait> ...`
+    pub bound_assumptions: &'hir [WherePredicate<'hir>],
+
     /// The constness and polarity of the trait ref.
     ///
     /// The `async` modifier is lowered directly into a different trait for now.
@@ -4758,7 +4763,7 @@ mod size_asserts {
     static_assert_size!(ForeignItem<'_>, 88);
     static_assert_size!(ForeignItemKind<'_>, 56);
     static_assert_size!(GenericArg<'_>, 16);
-    static_assert_size!(GenericBound<'_>, 64);
+    static_assert_size!(GenericBound<'_>, 80);
     static_assert_size!(Generics<'_>, 56);
     static_assert_size!(Impl<'_>, 80);
     static_assert_size!(ImplItem<'_>, 88);

compiler/rustc_hir/src/intravisit.rs

@@ -1065,10 +1065,12 @@ pub fn walk_where_predicate<'v, V: Visitor<'v>>(
             ref bounded_ty,
             bounds,
             bound_generic_params,
+            bound_assumptions,
             origin: _,
         }) => {
             try_visit!(visitor.visit_ty_unambig(bounded_ty));
             walk_list!(visitor, visit_param_bound, bounds);
+            walk_list!(visitor, visit_where_predicate, bound_assumptions);
             walk_list!(visitor, visit_generic_param, bound_generic_params);
         }
         WherePredicateKind::RegionPredicate(WhereRegionPredicate {
@@ -1277,6 +1279,7 @@ pub fn walk_poly_trait_ref<'v, V: Visitor<'v>>(
     trait_ref: &'v PolyTraitRef<'v>,
 ) -> V::Result {
     walk_list!(visitor, visit_generic_param, trait_ref.bound_generic_params);
+    walk_list!(visitor, visit_where_predicate, trait_ref.bound_assumptions);
     visitor.visit_trait_ref(&trait_ref.trait_ref)
 }
 

compiler/rustc_hir_analysis/src/collect/item_bounds.rs

@@ -38,7 +38,14 @@ fn associated_type_bounds<'tcx>(
 
         let icx = ItemCtxt::new(tcx, assoc_item_def_id);
         let mut bounds = Vec::new();
-        icx.lowerer().lower_bounds(item_ty, hir_bounds, &mut bounds, ty::List::empty(), filter);
+        icx.lowerer().lower_bounds(
+            item_ty,
+            hir_bounds,
+            &mut bounds,
+            ty::List::empty(),
+            ty::ListWithCachedTypeInfo::empty(),
+            filter,
+        );
         // Associated types are implicitly sized unless a `?Sized` bound is found
         match filter {
             PredicateFilter::All
@@ -327,7 +334,14 @@ fn opaque_type_bounds<'tcx>(
     ty::print::with_reduced_queries!({
         let icx = ItemCtxt::new(tcx, opaque_def_id);
         let mut bounds = Vec::new();
-        icx.lowerer().lower_bounds(item_ty, hir_bounds, &mut bounds, ty::List::empty(), filter);
+        icx.lowerer().lower_bounds(
+            item_ty,
+            hir_bounds,
+            &mut bounds,
+            ty::List::empty(),
+            ty::ListWithCachedTypeInfo::empty(),
+            filter,
+        );
         // Opaque types are implicitly sized unless a `?Sized` bound is found
         match filter {
             PredicateFilter::All

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -10,13 +10,13 @@ use rustc_middle::ty::{
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::{DUMMY_SP, Ident, Span};
-use tracing::{debug, instrument, trace};
+use tracing::{debug, instrument};
 
 use super::item_bounds::explicit_item_bounds_with_filter;
 use crate::collect::ItemCtxt;
 use crate::constrained_generic_params as cgp;
 use crate::delegation::inherit_predicates_for_delegation_item;
-use crate::hir_ty_lowering::{HirTyLowerer, PredicateFilter, RegionInferReason};
+use crate::hir_ty_lowering::{HirTyLowerer, PredicateFilter};
 
 /// Returns a list of all type predicates (explicit and implicit) for the definition with
 /// ID `def_id`. This includes all predicates returned by `explicit_predicates_of`, plus
@@ -183,6 +183,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
             self_bounds,
             &mut bounds,
             ty::List::empty(),
+            ty::ListWithCachedTypeInfo::empty(),
             PredicateFilter::All,
         );
         predicates.extend(bounds);
@@ -200,105 +201,11 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
         predicates.insert((trait_ref.upcast(tcx), tcx.def_span(def_id)));
     }
 
-    // Add implicit predicates that should be treated as if the user has written them,
-    // including the implicit `T: Sized` for all generic parameters, and `ConstArgHasType`
-    // for const params.
-    for param in hir_generics.params {
-        match param.kind {
-            GenericParamKind::Lifetime { .. } => (),
-            GenericParamKind::Type { .. } => {
-                let param_ty = icx.lowerer().lower_ty_param(param.hir_id);
-                let mut bounds = Vec::new();
-                // Params are implicitly sized unless a `?Sized` bound is found
-                icx.lowerer().add_sized_bound(
-                    &mut bounds,
-                    param_ty,
-                    &[],
-                    Some((param.def_id, hir_generics.predicates)),
-                    param.span,
-                );
-                trace!(?bounds);
-                predicates.extend(bounds);
-                trace!(?predicates);
-            }
-            hir::GenericParamKind::Const { .. } => {
-                let param_def_id = param.def_id.to_def_id();
-                let ct_ty = tcx.type_of(param_def_id).instantiate_identity();
-                let ct = icx.lowerer().lower_const_param(param_def_id, param.hir_id);
-                predicates
-                    .insert((ty::ClauseKind::ConstArgHasType(ct, ct_ty).upcast(tcx), param.span));
-            }
-        }
-    }
-
-    trace!(?predicates);
-    // Add inline `<T: Foo>` bounds and bounds in the where clause.
-    for predicate in hir_generics.predicates {
-        match predicate.kind {
-            hir::WherePredicateKind::BoundPredicate(bound_pred) => {
-                let ty = icx.lowerer().lower_ty_maybe_return_type_notation(bound_pred.bounded_ty);
-
-                let bound_vars = tcx.late_bound_vars(predicate.hir_id);
-                // 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.upcast(tcx), span));
-                    }
-                }
-
-                let mut bounds = Vec::new();
-                icx.lowerer().lower_bounds(
-                    ty,
-                    bound_pred.bounds,
-                    &mut bounds,
-                    bound_vars,
-                    PredicateFilter::All,
-                );
-                predicates.extend(bounds);
-            }
-
-            hir::WherePredicateKind::RegionPredicate(region_pred) => {
-                let r1 = icx
-                    .lowerer()
-                    .lower_lifetime(region_pred.lifetime, RegionInferReason::RegionPredicate);
-                predicates.extend(region_pred.bounds.iter().map(|bound| {
-                    let (r2, span) = match bound {
-                        hir::GenericBound::Outlives(lt) => (
-                            icx.lowerer().lower_lifetime(lt, RegionInferReason::RegionPredicate),
-                            lt.ident.span,
-                        ),
-                        bound => {
-                            span_bug!(
-                                bound.span(),
-                                "lifetime param bounds must be outlives, but found {bound:?}"
-                            )
-                        }
-                    };
-                    let pred =
-                        ty::ClauseKind::RegionOutlives(ty::OutlivesPredicate(r1, r2)).upcast(tcx);
-                    (pred, span)
-                }))
-            }
-
-            hir::WherePredicateKind::EqPredicate(..) => {
-                // FIXME(#20041)
-            }
-        }
-    }
+    icx.lowerer().lower_where_predicates(
+        hir_generics.params,
+        hir_generics.predicates,
+        &mut predicates,
+    );
 
     if tcx.features().generic_const_exprs() {
         predicates.extend(const_evaluatable_predicates_of(tcx, def_id, &predicates));
@@ -623,7 +530,14 @@ pub(super) fn implied_predicates_with_filter<'tcx>(
 
     let self_param_ty = tcx.types.self_param;
     let mut bounds = Vec::new();
-    icx.lowerer().lower_bounds(self_param_ty, superbounds, &mut bounds, ty::List::empty(), filter);
+    icx.lowerer().lower_bounds(
+        self_param_ty,
+        superbounds,
+        &mut bounds,
+        ty::List::empty(),
+        ty::ListWithCachedTypeInfo::empty(),
+        filter,
+    );
 
     let where_bounds_that_match =
         icx.probe_ty_param_bounds_in_generics(generics, item.owner_id.def_id, filter);
@@ -923,12 +837,24 @@ impl<'tcx> ItemCtxt<'tcx> {
 
             let bound_ty = self.lowerer().lower_ty_maybe_return_type_notation(predicate.bounded_ty);
 
+            let mut bound_assumptions = FxIndexSet::default();
+            if self.tcx.features().non_lifetime_binders() {
+                self.lowerer().lower_where_predicates(
+                    predicate.bound_generic_params,
+                    predicate.bound_assumptions,
+                    &mut bound_assumptions,
+                );
+            }
+            let bound_assumptions =
+                self.tcx().mk_clauses_from_iter(bound_assumptions.into_iter().map(|(c, _)| c));
+
             let bound_vars = self.tcx.late_bound_vars(hir_id);
             self.lowerer().lower_bounds(
                 bound_ty,
                 predicate.bounds,
                 &mut bounds,
                 bound_vars,
+                bound_assumptions,
                 filter,
             );
         }
@@ -1002,12 +928,25 @@ pub(super) fn const_conditions<'tcx>(
         match pred.kind {
             hir::WherePredicateKind::BoundPredicate(bound_pred) => {
                 let ty = icx.lowerer().lower_ty_maybe_return_type_notation(bound_pred.bounded_ty);
+
+                let mut bound_assumptions = FxIndexSet::default();
+                if tcx.features().non_lifetime_binders() {
+                    icx.lowerer().lower_where_predicates(
+                        bound_pred.bound_generic_params,
+                        bound_pred.bound_assumptions,
+                        &mut bound_assumptions,
+                    );
+                }
+                let bound_assumptions =
+                    icx.tcx().mk_clauses_from_iter(bound_assumptions.into_iter().map(|(c, _)| c));
+
                 let bound_vars = tcx.late_bound_vars(pred.hir_id);
                 icx.lowerer().lower_bounds(
                     ty,
                     bound_pred.bounds.iter(),
                     &mut bounds,
                     bound_vars,
+                    bound_assumptions,
                     PredicateFilter::ConstIfConst,
                 );
             }
@@ -1028,6 +967,7 @@ pub(super) fn const_conditions<'tcx>(
             supertraits,
             &mut bounds,
             ty::List::empty(),
+            ty::ListWithCachedTypeInfo::empty(),
             PredicateFilter::ConstIfConst,
         );
     }