More robustly reject relaxing non-default trait bounds

fmease · fmease · commit 91d1ed259c8f · 2025-10-15T19:46:00.000+02:00
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -204,7 +204,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             //        FIXME(more_maybe_bounds): We don't call this for trait object tys, supertrait
             //                                  bounds, trait alias bounds, assoc type bounds (ATB)!
             let bounds = collect_relaxed_bounds(hir_bounds, self_ty_where_predicates);
-            self.check_and_report_invalid_relaxed_bounds(bounds);
+            self.reject_duplicate_relaxed_bounds(bounds);
         }
 
         let collected = collect_sizedness_bounds(tcx, hir_bounds, self_ty_where_predicates, span);
@@ -308,6 +308,52 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         !self.tcx().has_attr(CRATE_DEF_ID, sym::rustc_no_implicit_bounds) && !collected.any()
     }
 
+    fn reject_duplicate_relaxed_bounds(&self, relaxed_bounds: SmallVec<[&PolyTraitRef<'_>; 1]>) {
+        let tcx = self.tcx();
+
+        let mut grouped_bounds = FxIndexMap::<_, Vec<_>>::default();
+
+        for bound in &relaxed_bounds {
+            if let Res::Def(DefKind::Trait, trait_def_id) = bound.trait_ref.path.res {
+                grouped_bounds.entry(trait_def_id).or_default().push(bound.span);
+            }
+        }
+
+        for (trait_def_id, spans) in grouped_bounds {
+            if spans.len() > 1 {
+                let name = tcx.item_name(trait_def_id);
+                self.dcx()
+                    .struct_span_err(spans, format!("duplicate relaxed `{name}` bounds"))
+                    .with_code(E0203)
+                    .emit();
+            }
+        }
+    }
+
+    pub(crate) fn require_bound_to_relax_default_trait(
+        &self,
+        trait_ref: hir::TraitRef<'_>,
+        span: Span,
+    ) {
+        let Res::Def(DefKind::Trait, def_id) = trait_ref.path.res else { return };
+        let tcx = self.tcx();
+
+        if tcx.is_lang_item(def_id, hir::LangItem::Sized) || tcx.is_default_trait(def_id) {
+            return;
+        }
+
+        self.dcx().span_err(
+            span,
+            if tcx.sess.opts.unstable_opts.experimental_default_bounds
+                || tcx.features().more_maybe_bounds()
+            {
+                "bound modifier `?` can only be applied to default traits"
+            } else {
+                "bound modifier `?` can only be applied to `Sized`"
+            },
+        );
+    }
+
     /// Lower HIR bounds into `bounds` given the self type `param_ty` and the overarching late-bound vars if any.
     ///
     /// ### Examples
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -8,7 +8,7 @@ use rustc_errors::{
 };
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{self as hir, HirId, PolyTraitRef};
+use rustc_hir::{self as hir, HirId};
 use rustc_middle::bug;
 use rustc_middle::ty::fast_reject::{TreatParams, simplify_type};
 use rustc_middle::ty::print::{PrintPolyTraitRefExt as _, PrintTraitRefExt as _};
@@ -35,52 +35,6 @@ use crate::fluent_generated as fluent;
 use crate::hir_ty_lowering::{AssocItemQSelf, HirTyLowerer};
 
 impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
-    /// Check for duplicate relaxed bounds and relaxed bounds of non-default traits.
-    pub(crate) fn check_and_report_invalid_relaxed_bounds(
-        &self,
-        relaxed_bounds: SmallVec<[&PolyTraitRef<'_>; 1]>,
-    ) {
-        let tcx = self.tcx();
-
-        let mut grouped_bounds = FxIndexMap::<_, Vec<_>>::default();
-
-        for bound in &relaxed_bounds {
-            if let Res::Def(DefKind::Trait, trait_def_id) = bound.trait_ref.path.res {
-                grouped_bounds.entry(trait_def_id).or_default().push(bound.span);
-            }
-        }
-
-        for (trait_def_id, spans) in grouped_bounds {
-            if spans.len() > 1 {
-                let name = tcx.item_name(trait_def_id);
-                self.dcx()
-                    .struct_span_err(spans, format!("duplicate relaxed `{name}` bounds"))
-                    .with_code(E0203)
-                    .emit();
-            }
-        }
-
-        let sized_def_id = tcx.require_lang_item(hir::LangItem::Sized, DUMMY_SP);
-
-        for bound in relaxed_bounds {
-            if let Res::Def(DefKind::Trait, def_id) = bound.trait_ref.path.res
-                && (def_id == sized_def_id || tcx.is_default_trait(def_id))
-            {
-                continue;
-            }
-            self.dcx().span_err(
-                bound.span,
-                if tcx.sess.opts.unstable_opts.experimental_default_bounds
-                    || tcx.features().more_maybe_bounds()
-                {
-                    "bound modifier `?` can only be applied to default traits like `Sized`"
-                } else {
-                    "bound modifier `?` can only be applied to `Sized`"
-                },
-            );
-        }
-    }
-
     /// On missing type parameters, emit an E0393 error and provide a structured suggestion using
     /// the type parameter's name as a placeholder.
     pub(crate) fn report_missing_type_params(
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -767,7 +767,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         // We use the *resolved* bound vars later instead of the HIR ones since the former
         // also include the bound vars of the overarching predicate if applicable.
-        let hir::PolyTraitRef { bound_generic_params: _, modifiers, ref trait_ref, span } =
+        let hir::PolyTraitRef { bound_generic_params: _, modifiers, trait_ref, span } =
             *poly_trait_ref;
         let hir::TraitBoundModifiers { constness, polarity } = modifiers;
 
@@ -791,6 +791,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             rustc_ast::BoundPolarity::Positive => (ty::PredicatePolarity::Positive, bounds),
             rustc_ast::BoundPolarity::Negative(_) => (ty::PredicatePolarity::Negative, bounds),
             rustc_ast::BoundPolarity::Maybe(_) => {
+                self.require_bound_to_relax_default_trait(trait_ref, span);
+
                 (ty::PredicatePolarity::Positive, &mut Vec::new())
             }
         };
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -1782,9 +1782,7 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     pub fn is_default_trait(self, def_id: DefId) -> bool {
-        self.default_traits()
-            .iter()
-            .any(|&default_trait| self.lang_items().get(default_trait) == Some(def_id))
+        self.default_traits().iter().any(|&default_trait| self.is_lang_item(def_id, default_trait))
     }
 
     /// Returns a range of the start/end indices specified with the
diff --git a/tests/ui/trait-bounds/more_maybe_bounds.rs b/tests/ui/trait-bounds/more_maybe_bounds.rs
@@ -1,40 +1,40 @@
-// FIXME(more_maybe_bounds): Even under `more_maybe_bounds` / `-Zexperimental-default-bounds`,
-// trying to relax non-default bounds should still be an error in all contexts! As you can see
-// there are places like supertrait bounds, trait object types or associated type bounds (ATB)
-// where we currently don't perform this check.
 #![feature(auto_traits, more_maybe_bounds, negative_impls)]
 
 trait Trait1 {}
 auto trait Trait2 {}
 
-// FIXME: `?Trait1` should be rejected, `Trait1` isn't marked `#[lang = "default_traitN"]`.
 trait Trait3: ?Trait1 {}
+//~^ ERROR bound modifier `?` can only be applied to default traits
+//~| ERROR bound modifier `?` can only be applied to default traits
+//~| ERROR bound modifier `?` can only be applied to default traits
 trait Trait4 where Self: Trait1 {}
 
-// FIXME: `?Trait2` should be rejected, `Trait2` isn't marked `#[lang = "default_traitN"]`.
+
 fn foo(_: Box<(dyn Trait3 + ?Trait2)>) {}
+//~^ ERROR bound modifier `?` can only be applied to default traits
 
 fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
-//~^ ERROR bound modifier `?` can only be applied to default traits like `Sized`
-//~| ERROR bound modifier `?` can only be applied to default traits like `Sized`
-//~| ERROR bound modifier `?` can only be applied to default traits like `Sized`
+//~^ ERROR bound modifier `?` can only be applied to default traits
+//~| ERROR bound modifier `?` can only be applied to default traits
+//~| ERROR bound modifier `?` can only be applied to default traits
 
-// FIXME: `?Trait1` should be rejected, `Trait1` isn't marked `#[lang = "default_traitN"]`.
 fn baz<T>() where T: Iterator<Item: ?Trait1> {}
 //~^ ERROR this relaxed bound is not permitted here
+//~| ERROR bound modifier `?` can only be applied to default traits
 
 struct S1<T>(T);
 
 impl<T> S1<T> {
     fn f() where T: ?Trait1 {}
     //~^ ERROR this relaxed bound is not permitted here
+    //~| ERROR bound modifier `?` can only be applied to default traits
 }
 
 trait Trait5<'a> {}
 
 struct S2<T>(T) where for<'a> T: ?Trait5<'a>;
 //~^ ERROR this relaxed bound is not permitted here
-//~| ERROR bound modifier `?` can only be applied to default traits like `Sized`
+//~| ERROR bound modifier `?` can only be applied to default traits
 
 struct S;
 impl !Trait2 for S {}
diff --git a/tests/ui/trait-bounds/more_maybe_bounds.stderr b/tests/ui/trait-bounds/more_maybe_bounds.stderr
@@ -1,13 +1,13 @@
 error: this relaxed bound is not permitted here
-  --> $DIR/more_maybe_bounds.rs:23:37
+  --> $DIR/more_maybe_bounds.rs:21:37
    |
 LL | fn baz<T>() where T: Iterator<Item: ?Trait1> {}
    |                                     ^^^^^^^
    |
    = note: in this context, relaxed bounds are only allowed on type parameters defined on the closest item
 
 error: this relaxed bound is not permitted here
-  --> $DIR/more_maybe_bounds.rs:29:21
+  --> $DIR/more_maybe_bounds.rs:28:21
    |
 LL |     fn f() where T: ?Trait1 {}
    |                     ^^^^^^^
@@ -22,29 +22,69 @@ LL | struct S2<T>(T) where for<'a> T: ?Trait5<'a>;
    |
    = note: in this context, relaxed bounds are only allowed on type parameters defined on the closest item
 
-error: bound modifier `?` can only be applied to default traits like `Sized`
-  --> $DIR/more_maybe_bounds.rs:17:20
+error: bound modifier `?` can only be applied to default traits
+  --> $DIR/more_maybe_bounds.rs:6:15
+   |
+LL | trait Trait3: ?Trait1 {}
+   |               ^^^^^^^
+
+error: bound modifier `?` can only be applied to default traits
+  --> $DIR/more_maybe_bounds.rs:6:15
+   |
+LL | trait Trait3: ?Trait1 {}
+   |               ^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: bound modifier `?` can only be applied to default traits
+  --> $DIR/more_maybe_bounds.rs:6:15
+   |
+LL | trait Trait3: ?Trait1 {}
+   |               ^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: bound modifier `?` can only be applied to default traits
+  --> $DIR/more_maybe_bounds.rs:13:29
+   |
+LL | fn foo(_: Box<(dyn Trait3 + ?Trait2)>) {}
+   |                             ^^^^^^^
+
+error: bound modifier `?` can only be applied to default traits
+  --> $DIR/more_maybe_bounds.rs:16:20
    |
 LL | fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
    |                    ^^^^^^^
 
-error: bound modifier `?` can only be applied to default traits like `Sized`
-  --> $DIR/more_maybe_bounds.rs:17:30
+error: bound modifier `?` can only be applied to default traits
+  --> $DIR/more_maybe_bounds.rs:16:30
    |
 LL | fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
    |                              ^^^^^^^
 
-error: bound modifier `?` can only be applied to default traits like `Sized`
-  --> $DIR/more_maybe_bounds.rs:17:40
+error: bound modifier `?` can only be applied to default traits
+  --> $DIR/more_maybe_bounds.rs:16:40
    |
 LL | fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
    |                                        ^^^^^^^
 
-error: bound modifier `?` can only be applied to default traits like `Sized`
+error: bound modifier `?` can only be applied to default traits
+  --> $DIR/more_maybe_bounds.rs:21:37
+   |
+LL | fn baz<T>() where T: Iterator<Item: ?Trait1> {}
+   |                                     ^^^^^^^
+
+error: bound modifier `?` can only be applied to default traits
   --> $DIR/more_maybe_bounds.rs:35:34
    |
 LL | struct S2<T>(T) where for<'a> T: ?Trait5<'a>;
    |                                  ^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: bound modifier `?` can only be applied to default traits
+  --> $DIR/more_maybe_bounds.rs:28:21
+   |
+LL |     fn f() where T: ?Trait1 {}
+   |                     ^^^^^^^
+
+error: aborting due to 13 previous errors
 

Original file line number	Diff line number	Diff line change
`@@ -1782,9 +1782,7 @@ impl<'tcx> TyCtxt<'tcx> {`
`1782`	`1782`	`}`
`1783`	`1783`
`1784`	`1784`	`pub fn is_default_trait(self, def_id: DefId) -> bool {`
`1785`		`- self.default_traits()`
`1786`		`- .iter()`
`1787`		`- .any(\|&default_trait\| self.lang_items().get(default_trait) == Some(def_id))`
	`1785`	`+ self.default_traits().iter().any(\|&default_trait\| self.is_lang_item(def_id, default_trait))`
`1788`	`1786`	`}`
`1789`	`1787`
`1790`	`1788`	`/// Returns a range of the start/end indices specified with the`