hir_analysis: add missing sizedness bounds

davidtwco · davidtwco · commit 4d5905de8547 · 2025-10-13T14:17:51.000+01:00
Default sizedness bounds were not being added to
`explicit_super_predicates_of` and `explicit_implied_predicates_of`
which meant that a trait bound added to a associated type projection
would be missing the implied predicate of the default sizedness
supertrait of that trait.

An unexpected consequence of this change was that the check for multiple
principals was now finding an additional `MetaSized` principal when
eagerly expanding trait aliases. Instead of special-casing trait aliases
as different from traits and not adding a `MetaSized` supertrait to trait
aliases, filter out `MetaSized` when lowering `dyn Trait`.
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -676,6 +676,14 @@ pub(super) fn implied_predicates_with_filter<'tcx>(
         | PredicateFilter::SelfOnly
         | PredicateFilter::SelfTraitThatDefines(_)
         | PredicateFilter::SelfAndAssociatedTypeBounds => {
+            icx.lowerer().add_sizedness_bounds(
+                &mut bounds,
+                self_param_ty,
+                superbounds,
+                None,
+                Some(trait_def_id),
+                item.span,
+            );
             icx.lowerer().add_default_super_traits(
                 trait_def_id,
                 &mut bounds,
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
@@ -4,9 +4,9 @@ use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, EmissionGuarantee, StashKey, Suggestions, struct_span_code_err,
 };
-use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir, LangItem};
 use rustc_lint_defs::builtin::{BARE_TRAIT_OBJECTS, UNUSED_ASSOCIATED_TYPE_BOUNDS};
 use rustc_middle::ty::elaborate::ClauseWithSupertraitSpan;
 use rustc_middle::ty::{
@@ -80,8 +80,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             span,
         );
 
-        let (elaborated_trait_bounds, elaborated_projection_bounds) =
+        let (mut elaborated_trait_bounds, elaborated_projection_bounds) =
             traits::expand_trait_aliases(tcx, user_written_bounds.iter().copied());
+
+        // FIXME(sized-hierarchy): https://github.com/rust-lang/rust/pull/142712#issuecomment-3013231794
+        let meta_sized_did = tcx.require_lang_item(LangItem::MetaSized, span);
+        elaborated_trait_bounds.retain(|(pred, _)| pred.def_id() != meta_sized_did);
+
         let (regular_traits, mut auto_traits): (Vec<_>, Vec<_>) = elaborated_trait_bounds
             .into_iter()
             .partition(|(trait_ref, _)| !tcx.trait_is_auto(trait_ref.def_id()));
diff --git a/tests/ui/sized-hierarchy/bound-on-assoc-type-projection.rs b/tests/ui/sized-hierarchy/bound-on-assoc-type-projection.rs
@@ -0,0 +1,15 @@
+//@ check-pass
+#![crate_type = "lib"]
+#![feature(sized_hierarchy)]
+
+trait FalseDeref {
+    type Target: std::marker::PointeeSized;
+}
+
+trait Bar {}
+
+fn foo<T: FalseDeref>()
+where
+    T::Target: Bar,
+{
+}
diff --git a/tests/ui/sized-hierarchy/default-supertrait.rs b/tests/ui/sized-hierarchy/default-supertrait.rs
@@ -47,14 +47,11 @@ fn with_pointeesized_supertrait<T: PointeeSized + PointeeSized_>() {
     requires_pointeesized::<T>();
 }
 
-// `T` won't inherit the `const MetaSized` implicit supertrait of `Bare`, so there is an error on
-// the bound, which is expected.
+// `T` inherits the `const MetaSized` implicit supertrait of `Bare`.
 fn with_bare_trait<T: PointeeSized + Bare>() {
-//~^ ERROR the size for values of type `T` cannot be known
     requires_sized::<T>();
     //~^ ERROR the size for values of type `T` cannot be known
     requires_metasized::<T>();
-    //~^ ERROR the size for values of type `T` cannot be known
     requires_pointeesized::<T>();
 }
 
diff --git a/tests/ui/sized-hierarchy/default-supertrait.stderr b/tests/ui/sized-hierarchy/default-supertrait.stderr
@@ -18,22 +18,6 @@ error: relaxed bounds are not permitted in supertrait bounds
 LL | trait NegPointeeSized: ?PointeeSized { }
    |                        ^^^^^^^^^^^^^
 
-error[E0277]: the size for values of type `T` cannot be known
-  --> $DIR/default-supertrait.rs:52:38
-   |
-LL | fn with_bare_trait<T: PointeeSized + Bare>() {
-   |                                      ^^^^ doesn't have a known size
-   |
-note: required by a bound in `Bare`
-  --> $DIR/default-supertrait.rs:22:1
-   |
-LL | trait Bare {}
-   | ^^^^^^^^^^^^^ required by this bound in `Bare`
-help: consider further restricting type parameter `T` with unstable trait `MetaSized`
-   |
-LL | fn with_bare_trait<T: PointeeSized + Bare + std::marker::MetaSized>() {
-   |                                           ++++++++++++++++++++++++
-
 error[E0277]: the size for values of type `T` cannot be known at compilation time
   --> $DIR/default-supertrait.rs:35:22
    |
@@ -79,11 +63,10 @@ LL | fn with_pointeesized_supertrait<T: PointeeSized + PointeeSized_ + std::mark
    |                                                                 ++++++++++++++++++++++++
 
 error[E0277]: the size for values of type `T` cannot be known at compilation time
-  --> $DIR/default-supertrait.rs:54:22
+  --> $DIR/default-supertrait.rs:52:22
    |
 LL | fn with_bare_trait<T: PointeeSized + Bare>() {
    |                    - this type parameter needs to be `Sized`
-LL |
 LL |     requires_sized::<T>();
    |                      ^ doesn't have a size known at compile-time
    |
@@ -93,22 +76,6 @@ note: required by a bound in `requires_sized`
 LL | fn requires_sized<T: Sized>() {}
    |                      ^^^^^ required by this bound in `requires_sized`
 
-error[E0277]: the size for values of type `T` cannot be known
-  --> $DIR/default-supertrait.rs:56:26
-   |
-LL |     requires_metasized::<T>();
-   |                          ^ doesn't have a known size
-   |
-note: required by a bound in `requires_metasized`
-  --> $DIR/default-supertrait.rs:25:26
-   |
-LL | fn requires_metasized<T: MetaSized>() {}
-   |                          ^^^^^^^^^ required by this bound in `requires_metasized`
-help: consider further restricting type parameter `T` with unstable trait `MetaSized`
-   |
-LL | fn with_bare_trait<T: PointeeSized + Bare + std::marker::MetaSized>() {
-   |                                           ++++++++++++++++++++++++
-
-error: aborting due to 9 previous errors
+error: aborting due to 7 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/sized-hierarchy/elaboration-simple.rs b/tests/ui/sized-hierarchy/elaboration-simple.rs
@@ -0,0 +1,7 @@
+//@ check-pass
+//@ compile-flags: --crate-type=lib
+#![feature(sized_hierarchy)]
+
+trait Trait {}
+
+fn f<T: Trait + std::marker::PointeeSized>() {}
diff --git a/tests/ui/traits/next-solver/normalize/normalize-param-env-2.stderr b/tests/ui/traits/next-solver/normalize/normalize-param-env-2.stderr
@@ -19,23 +19,6 @@ error[E0275]: overflow evaluating the requirement `<() as A<T>>::Assoc: A<T>`
 LL |         Self::Assoc: A<T>,
    |                      ^^^^
 
-error[E0275]: overflow evaluating the requirement `<() as A<T>>::Assoc: MetaSized`
-  --> $DIR/normalize-param-env-2.rs:24:22
-   |
-LL |         Self::Assoc: A<T>,
-   |                      ^^^^
-   |
-note: required by a bound in `A`
-  --> $DIR/normalize-param-env-2.rs:9:1
-   |
-LL | / trait A<T> {
-LL | |     type Assoc;
-LL | |
-LL | |     fn f()
-...  |
-LL | | }
-   | |_^ required by this bound in `A`
-
 error[E0275]: overflow evaluating the requirement `<() as A<T>>::Assoc well-formed`
   --> $DIR/normalize-param-env-2.rs:24:22
    |
@@ -63,6 +46,6 @@ LL |     where
 LL |         Self::Assoc: A<T>,
    |                      ^^^^ required by this bound in `A::f`
 
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/normalize/normalize-param-env-4.next.stderr b/tests/ui/traits/next-solver/normalize/normalize-param-env-4.next.stderr
@@ -4,20 +4,6 @@ error[E0275]: overflow evaluating the requirement `<T as Trait>::Assoc: Trait`
 LL |     <T as Trait>::Assoc: Trait,
    |                          ^^^^^
 
-error[E0275]: overflow evaluating the requirement `<T as Trait>::Assoc: MetaSized`
-  --> $DIR/normalize-param-env-4.rs:19:26
-   |
-LL |     <T as Trait>::Assoc: Trait,
-   |                          ^^^^^
-   |
-note: required by a bound in `Trait`
-  --> $DIR/normalize-param-env-4.rs:7:1
-   |
-LL | / trait Trait {
-LL | |     type Assoc;
-LL | | }
-   | |_^ required by this bound in `Trait`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.

Original file line number	Diff line number	Diff line change
`@@ -47,14 +47,11 @@ fn with_pointeesized_supertrait<T: PointeeSized + PointeeSized_>() {`
`47`	`47`	`requires_pointeesized::<T>();`
`48`	`48`	`}`
`49`	`49`
`50`		-// `T` won't inherit the `const MetaSized` implicit supertrait of `Bare`, so there is an error on
`51`		`-// the bound, which is expected.`
	`50`	+// `T` inherits the `const MetaSized` implicit supertrait of `Bare`.
`52`	`51`	`fn with_bare_trait<T: PointeeSized + Bare>() {`
`53`		-//~^ ERROR the size for values of type `T` cannot be known
`54`	`52`	`requires_sized::<T>();`
`55`	`53`	//~^ ERROR the size for values of type `T` cannot be known
`56`	`54`	`requires_metasized::<T>();`
`57`		- //~^ ERROR the size for values of type `T` cannot be known
`58`	`55`	`requires_pointeesized::<T>();`
`59`	`56`	`}`
`60`	`57`