make Thin a supertrait of Sized

Author: Lukas Markeffsky

compiler/rustc_trait_selection/src/solve/normalizes_to/mod.rs

@@ -541,22 +541,6 @@ impl<'tcx> assembly::GoalKind<'tcx> for NormalizesTo<'tcx> {
                         .instantiate(tcx, &[ty::GenericArg::from(goal.predicate.self_ty())])
                 }
 
-                ty::Alias(_, _) | ty::Param(_) | ty::Placeholder(..) => {
-                    // This is the "fallback impl" for type parameters, unnormalizable projections
-                    // and opaque types: If the `self_ty` is `Sized`, then the metadata is `()`.
-                    // FIXME(ptr_metadata): This impl overlaps with the other impls and shouldn't
-                    // exist. Instead, `Pointee<Metadata = ()>` should be a supertrait of `Sized`.
-                    let sized_predicate = ty::TraitRef::from_lang_item(
-                        tcx,
-                        LangItem::Sized,
-                        DUMMY_SP,
-                        [ty::GenericArg::from(goal.predicate.self_ty())],
-                    );
-                    // FIXME(-Znext-solver=coinductive): Should this be `GoalSource::ImplWhereBound`?
-                    ecx.add_goal(GoalSource::Misc, goal.with(tcx, sized_predicate));
-                    tcx.types.unit
-                }
-
                 ty::Adt(def, args) if def.is_struct() => match def.non_enum_variant().tail_opt() {
                     None => tcx.types.unit,
                     Some(tail_def) => {
@@ -571,6 +555,10 @@ impl<'tcx> assembly::GoalKind<'tcx> for NormalizesTo<'tcx> {
                     Some(&tail_ty) => Ty::new_projection(tcx, metadata_def_id, [tail_ty]),
                 },
 
+                // The metadata of these types can only be known from param env or alias bound
+                // candidates.
+                ty::Alias(_, _) | ty::Param(_) | ty::Placeholder(..) => return Err(NoSolution),
+
                 ty::Infer(
                     ty::TyVar(_) | ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_),
                 )

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

@@ -123,17 +123,31 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             })
             .collect();
 
+        #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+        enum ErrorOrd {
+            Default,
+            Sized,
+            Metadata,
+            Coerce,
+            WellFormed,
+        }
+
         // Ensure `T: Sized` and `T: WF` obligations come last. This lets us display diagnostics
         // with more relevant type information and hide redundant E0282 ("type annotations needed") errors.
         errors.sort_by_key(|e| match e.obligation.predicate.kind().skip_binder() {
             ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred))
                 if Some(pred.def_id()) == self.tcx.lang_items().sized_trait() =>
             {
-                1
+                ErrorOrd::Sized
+            }
+            ty::PredicateKind::Clause(ty::ClauseKind::Projection(pred))
+                if Some(pred.def_id()) == self.tcx.lang_items().metadata_type() =>
+            {
+                ErrorOrd::Metadata
             }
-            ty::PredicateKind::Coerce(_) => 2,
-            ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(_)) => 3,
-            _ => 0,
+            ty::PredicateKind::Coerce(_) => ErrorOrd::Coerce,
+            ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(_)) => ErrorOrd::WellFormed,
+            _ => ErrorOrd::Default,
         });
 
         for (index, error) in errors.iter().enumerate() {

compiler/rustc_trait_selection/src/traits/project.rs

@@ -23,7 +23,6 @@ use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use crate::infer::{BoundRegionConversionTime, InferOk};
 use crate::traits::normalize::normalize_with_depth;
 use crate::traits::normalize::normalize_with_depth_to;
-use crate::traits::query::evaluate_obligation::InferCtxtExt as _;
 use crate::traits::select::ProjectionMatchesProjection;
 use rustc_data_structures::sso::SsoHashSet;
 use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -975,9 +974,12 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                 //
                 // NOTE: This should be kept in sync with the similar code in
                 // `rustc_ty_utils::instance::resolve_associated_item()`.
-                let node_item =
-                    specialization_graph::assoc_def(selcx.tcx(), impl_data.impl_def_id, obligation.predicate.def_id)
-                        .map_err(|ErrorGuaranteed { .. }| ())?;
+                let node_item = specialization_graph::assoc_def(
+                    selcx.tcx(),
+                    impl_data.impl_def_id,
+                    obligation.predicate.def_id,
+                )
+                .map_err(|ErrorGuaranteed { .. }| ())?;
 
                 if node_item.is_final() {
                     // Non-specializable items are always projectable.
@@ -1020,7 +1022,8 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                     lang_items.async_fn_trait(),
                     lang_items.async_fn_mut_trait(),
                     lang_items.async_fn_once_trait(),
-                ].contains(&Some(trait_ref.def_id))
+                ]
+                .contains(&Some(trait_ref.def_id))
                 {
                     true
                 } else if lang_items.async_fn_kind_helper() == Some(trait_ref.def_id) {
@@ -1033,7 +1036,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                         true
                     } else {
                         obligation.predicate.args.type_at(0).to_opt_closure_kind().is_some()
-                        && obligation.predicate.args.type_at(1).to_opt_closure_kind().is_some()
+                            && obligation.predicate.args.type_at(1).to_opt_closure_kind().is_some()
                     }
                 } else if lang_items.discriminant_kind_trait() == Some(trait_ref.def_id) {
                     match self_ty.kind() {
@@ -1116,34 +1119,28 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                         // If returned by `struct_tail_without_normalization` this is the empty tuple.
                         | ty::Tuple(..)
                         // Integers and floats are always Sized, and so have unit type metadata.
-                        | ty::Infer(ty::InferTy::IntVar(_) | ty::InferTy::FloatVar(..)) => true,
+                        | ty::Infer(ty::InferTy::IntVar(_) | ty::InferTy::FloatVar(..))
+                        // `{type error}` is sized, so its metadata must be the unit type.
+                        | ty::Error(_) => true,
 
-                        // We normalize from `Wrapper<Tail>::Metadata` to `Tail::Metadata` if able.
-                        // Otherwise, type parameters, opaques, and unnormalized projections have
-                        // unit metadata if they're known (e.g. by the param_env) to be sized.
-                        ty::Param(_) | ty::Alias(..)
-                            if self_ty != tail || selcx.infcx.predicate_must_hold_modulo_regions(
-                                &obligation.with(
-                                    selcx.tcx(),
-                                    ty::TraitRef::from_lang_item(selcx.tcx(), LangItem::Sized, obligation.cause.span(),[self_ty]),
-                                ),
-                            ) =>
-                        {
-                            true
-                        }
+                        // We normalize from `Wrapper<Tail>::Metadata` to `Tail::Metadata`.
+                        ty::Param(_) | ty::Alias(..) => self_ty != tail,
 
-                        // FIXME(compiler-errors): are Bound and Placeholder types ever known sized?
-                        ty::Param(_)
-                        | ty::Alias(..)
-                        | ty::Bound(..)
-                        | ty::Placeholder(..)
-                        | ty::Infer(..)
-                        | ty::Error(_) => {
-                            if tail.has_infer_types() {
-                                candidate_set.mark_ambiguous();
-                            }
+                        // FIXME: These should probably project to the tail as well.
+                        ty::Bound(..) | ty::Placeholder(..) => false,
+
+                        ty::Infer(ty::TyVar(_)) => {
+                            candidate_set.mark_ambiguous();
                             false
                         }
+
+                        ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
+                            span_bug!(
+                                obligation.cause.span,
+                                "unexpected self ty `{self_ty:?}` when normalizing \
+                                `<T as Pointee>::Metadata`",
+                            )
+                        }
                     }
                 } else {
                     bug!("unexpected builtin trait with associated type: {trait_ref:?}")
@@ -1190,7 +1187,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                     obligation.cause.span,
                     format!("Cannot project an associated type from `{impl_source:?}`"),
                 );
-                return Err(())
+                return Err(());
             }
         };
 
@@ -1510,23 +1507,15 @@ fn confirm_builtin_candidate<'cx, 'tcx>(
         };
         let metadata_ty = self_ty.ptr_metadata_ty_or_tail(tcx, normalize).unwrap_or_else(|tail| {
             if tail == self_ty {
-                // This is the "fallback impl" for type parameters, unnormalizable projections
-                // and opaque types: If the `self_ty` is `Sized`, then the metadata is `()`.
-                // FIXME(ptr_metadata): This impl overlaps with the other impls and shouldn't
-                // exist. Instead, `Pointee<Metadata = ()>` should be a supertrait of `Sized`.
-                let sized_predicate = ty::TraitRef::from_lang_item(
-                    tcx,
-                    LangItem::Sized,
-                    obligation.cause.span(),
-                    [self_ty],
+                span_bug!(
+                    obligation.cause.span,
+                    "`<{self_ty:?} as Pointee>::Metadata` projection candidate assembled, \
+                    but we cannot project further",
                 );
-                obligations.push(obligation.with(tcx, sized_predicate));
-                tcx.types.unit
-            } else {
-                // We know that `self_ty` has the same metadata as `tail`. This allows us
-                // to prove predicates like `Wrapper<Tail>::Metadata == Tail::Metadata`.
-                Ty::new_projection(tcx, metadata_def_id, [tail])
             }
+            // We know that `self_ty` has the same metadata as `tail`. This allows us
+            // to prove predicates like `Wrapper<Tail>::Metadata == Tail::Metadata`.
+            Ty::new_projection(tcx, metadata_def_id, [tail])
         });
         (metadata_ty.into(), obligations)
     } else {

library/core/src/marker.rs

@@ -142,6 +142,19 @@ unsafe impl<T: Sync + ?Sized> Send for &T {}
 #[rustc_specialization_trait]
 #[rustc_deny_explicit_impl(implement_via_object = false)]
 #[rustc_coinductive]
+#[cfg(not(bootstrap))]
+pub trait Sized: crate::ptr::Thin {
+    // Empty.
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+#[lang = "sized"]
+#[fundamental]
+#[rustc_specialization_trait]
+#[rustc_deny_explicit_impl(implement_via_object = false)]
+#[rustc_coinductive]
+#[cfg(bootstrap)]
+#[allow(missing_docs)]
 pub trait Sized {
     // Empty.
 }

tests/ui/feature-gates/feature-gate-trivial_bounds.rs

@@ -53,6 +53,7 @@ struct TwoStrs(str, str) where str: Sized; //~ ERROR
 
 
 fn unsized_local() where Dst<dyn A>: Sized { //~ ERROR
+//~^ ERROR type mismatch resolving `<Dst<dyn A> as Pointee>::Metadata == ()`
     let x: Dst<dyn A> = *(Box::new(Dst { x: 1 }) as Box<Dst<dyn A>>);
 }
 

tests/ui/feature-gates/feature-gate-trivial_bounds.stderr

@@ -132,8 +132,20 @@ help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
 LL + #![feature(trivial_bounds)]
    |
 
+error[E0271]: type mismatch resolving `<Dst<dyn A> as Pointee>::Metadata == ()`
+  --> $DIR/feature-gate-trivial_bounds.rs:55:26
+   |
+LL | fn unsized_local() where Dst<dyn A>: Sized {
+   |                          ^^^^^^^^^^^^^^^^^ expected `DynMetadata<(dyn A + 'static)>`, found `()`
+   |
+   = help: see issue #48214
+help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+   |
+LL + #![feature(trivial_bounds)]
+   |
+
 error[E0277]: the size for values of type `str` cannot be known at compilation time
-  --> $DIR/feature-gate-trivial_bounds.rs:59:30
+  --> $DIR/feature-gate-trivial_bounds.rs:60:30
    |
 LL | fn return_str() -> str where str: Sized {
    |                              ^^^^^^^^^^ doesn't have a size known at compile-time
@@ -145,6 +157,7 @@ help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
 LL + #![feature(trivial_bounds)]
    |
 
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
 
-For more information about this error, try `rustc --explain E0277`.
+Some errors have detailed explanations: E0271, E0277.
+For more information about an error, try `rustc --explain E0271`.

tests/ui/generic-associated-types/issue-119942-unsatisified-gat-bound-during-assoc-ty-selection.stderr

@@ -32,6 +32,11 @@ LL | impl<T, P: PointerFamily> Node<T, P>
 LL | where
 LL |     P::Pointer<Node<T, P>>: Sized,
    |                             ^^^^^ unsatisfied trait bound introduced here
+   = note: the following trait bounds were not satisfied:
+           `(dyn Deref<Target = Node<i32, RcFamily>> + 'static): Thin`
+           which is required by `(dyn Deref<Target = Node<i32, RcFamily>> + 'static): Sized`
+           `<(dyn Deref<Target = Node<i32, RcFamily>> + 'static) as Pointee>::Metadata = ()`
+           which is required by `(dyn Deref<Target = Node<i32, RcFamily>> + 'static): Sized`
 
 error: aborting due to 2 previous errors
 

tests/ui/layout/layout-cycle.rs

@@ -8,6 +8,7 @@ use std::mem;
 
 pub struct S<T: Tr> {
     pub f: <T as Tr>::I,
+    _tail: (), // without this, we get "reached the recursion limit finding the struct tail" instead
 }
 
 pub trait Tr {

tests/ui/sized/recursive-type-coercion-from-never.rs

@@ -9,8 +9,8 @@ impl A for () {
     type Assoc = Foo<()>;
 }
 
-struct Foo<T: A>(T::Assoc);
+struct Foo<T: A>(T::Assoc, ());
 
 fn main() {
-    Foo::<()>(todo!());
+    Foo::<()>(todo!(), ());
 }

tests/ui/sized/recursive-type-pass.rs

@@ -5,6 +5,6 @@ impl A for () {
     // FIXME: it would be nice for this to at least cause a warning.
     type Assoc = Foo<()>;
 }
-struct Foo<T: A>(T::Assoc);
+struct Foo<T: A>(T::Assoc, ());
 
 fn main() {}