Auto merge of #154374 - lqd:rename-metasized, r=<try>

Rename `MetaSized` trait to `SizeOfVal`


try-job: dist-x86_64-linux

Author: bors

compiler/rustc_codegen_cranelift/example/mini_core.rs

@@ -18,11 +18,11 @@
 #[lang = "pointee_sized"]
 pub trait PointeeSized {}
 
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
+#[lang = "size_of_val"]
+pub trait SizeOfVal: PointeeSized {}
 
 #[lang = "sized"]
-pub trait Sized: MetaSized {}
+pub trait Sized: SizeOfVal {}
 
 #[lang = "destruct"]
 pub trait Destruct {}
@@ -52,14 +52,14 @@ impl<'a, T: PointeeSized + Unsize<U>, U: PointeeSized> DispatchFromDyn<&'a mut U
 impl<T: PointeeSized + Unsize<U>, U: PointeeSized> DispatchFromDyn<*const U> for *const T {}
 // *mut T -> *mut U
 impl<T: PointeeSized + Unsize<U>, U: PointeeSized> DispatchFromDyn<*mut U> for *mut T {}
-impl<T: MetaSized + Unsize<U>, U: MetaSized> DispatchFromDyn<Box<U>> for Box<T> {}
+impl<T: SizeOfVal + Unsize<U>, U: SizeOfVal> DispatchFromDyn<Box<U>> for Box<T> {}
 
 #[lang = "legacy_receiver"]
 pub trait LegacyReceiver {}
 
 impl<T: PointeeSized> LegacyReceiver for &T {}
 impl<T: PointeeSized> LegacyReceiver for &mut T {}
-impl<T: MetaSized> LegacyReceiver for Box<T> {}
+impl<T: SizeOfVal> LegacyReceiver for Box<T> {}
 
 #[lang = "copy"]
 pub trait Copy {}

compiler/rustc_codegen_gcc/example/mini_core.rs

@@ -22,11 +22,11 @@ unsafe extern "C" fn _Unwind_Resume() {
 #[lang = "pointee_sized"]
 pub trait PointeeSized {}
 
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
+#[lang = "size_of_val"]
+pub trait SizeOfVal: PointeeSized {}
 
 #[lang = "sized"]
-pub trait Sized: MetaSized {}
+pub trait Sized: SizeOfVal {}
 
 #[lang = "destruct"]
 pub trait Destruct {}
@@ -56,14 +56,14 @@ impl<'a, T: PointeeSized + Unsize<U>, U: PointeeSized> DispatchFromDyn<&'a mut U
 impl<T: PointeeSized + Unsize<U>, U: PointeeSized> DispatchFromDyn<*const U> for *const T {}
 // *mut T -> *mut U
 impl<T: PointeeSized + Unsize<U>, U: PointeeSized> DispatchFromDyn<*mut U> for *mut T {}
-impl<T: MetaSized + Unsize<U>, U: MetaSized> DispatchFromDyn<Box<U, ()>> for Box<T, ()> {}
+impl<T: SizeOfVal + Unsize<U>, U: SizeOfVal> DispatchFromDyn<Box<U, ()>> for Box<T, ()> {}
 
 #[lang = "legacy_receiver"]
 pub trait LegacyReceiver {}
 
 impl<T: PointeeSized> LegacyReceiver for &T {}
 impl<T: PointeeSized> LegacyReceiver for &mut T {}
-impl<T: MetaSized> LegacyReceiver for Box<T> {}
+impl<T: SizeOfVal> LegacyReceiver for Box<T> {}
 
 #[lang = "receiver"]
 trait Receiver {}

compiler/rustc_codegen_gcc/tests/run/simd-ffi.rs

@@ -62,11 +62,11 @@ pub fn bar(a: i32x4, b: i32x4) -> i32x4 {
 #[lang = "pointee_sized"]
 pub trait PointeeSized {}
 
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
+#[lang = "size_of_val"]
+pub trait SizeOfVal: PointeeSized {}
 
 #[lang = "sized"]
-pub trait Sized: MetaSized {}
+pub trait Sized: SizeOfVal {}
 
 #[lang = "copy"]
 pub trait Copy {}

compiler/rustc_hir/src/lang_items.rs

@@ -153,7 +153,7 @@ impl<CTX> HashStable<CTX> for LangItem {
 language_item_table! {
 //  Variant name,            Name,                     Getter method name,         Target                  Generic requirements;
     Sized,                   sym::sized,               sized_trait,                Target::Trait,          GenericRequirement::Exact(0);
-    MetaSized,               sym::meta_sized,          meta_sized_trait,           Target::Trait,          GenericRequirement::Exact(0);
+    SizeOfVal,               sym::size_of_val,         size_of_val_trait,          Target::Trait,          GenericRequirement::Exact(0);
     PointeeSized,            sym::pointee_sized,       pointee_sized_trait,        Target::Trait,          GenericRequirement::Exact(0);
     Unsize,                  sym::unsize,              unsize_trait,               Target::Trait,          GenericRequirement::Minimum(1);
     AlignOf,                 sym::mem_align_const,     align_const,                Target::AssocConst,     GenericRequirement::Exact(0);

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -376,7 +376,7 @@ fn bounds_from_generic_predicates<'tcx>(
                             projections_str.push(format!("{} = {}", name, p.term));
                         }
                     }
-                    let bound_def_path = if tcx.is_lang_item(bound, LangItem::MetaSized) {
+                    let bound_def_path = if tcx.is_lang_item(bound, LangItem::SizeOfVal) {
                         String::from("?Sized")
                     } else {
                         tcx.def_path_str(bound)

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -44,17 +44,17 @@ impl CollectedBound {
 struct CollectedSizednessBounds {
     // Collected `Sized` bounds
     sized: CollectedBound,
-    // Collected `MetaSized` bounds
-    meta_sized: CollectedBound,
+    // Collected `SizeOfVal` bounds
+    size_of_val: CollectedBound,
     // Collected `PointeeSized` bounds
     pointee_sized: CollectedBound,
 }
 
 impl CollectedSizednessBounds {
     /// Returns `true` if any of `Trait`, `?Trait` or `!Trait` were encountered for `Sized`,
-    /// `MetaSized` or `PointeeSized`.
+    /// `SizeOfVal` or `PointeeSized`.
     fn any(&self) -> bool {
-        self.sized.any() || self.meta_sized.any() || self.pointee_sized.any()
+        self.sized.any() || self.size_of_val.any() || self.pointee_sized.any()
     }
 }
 
@@ -127,13 +127,13 @@ fn collect_sizedness_bounds<'tcx>(
     let sized_did = tcx.require_lang_item(hir::LangItem::Sized, span);
     let sized = collect_bounds(hir_bounds, context, sized_did);
 
-    let meta_sized_did = tcx.require_lang_item(hir::LangItem::MetaSized, span);
-    let meta_sized = collect_bounds(hir_bounds, context, meta_sized_did);
+    let size_of_val_did = tcx.require_lang_item(hir::LangItem::SizeOfVal, span);
+    let size_of_val = collect_bounds(hir_bounds, context, size_of_val_did);
 
     let pointee_sized_did = tcx.require_lang_item(hir::LangItem::PointeeSized, span);
     let pointee_sized = collect_bounds(hir_bounds, context, pointee_sized_did);
 
-    CollectedSizednessBounds { sized, meta_sized, pointee_sized }
+    CollectedSizednessBounds { sized, size_of_val, pointee_sized }
 }
 
 /// Add a trait bound for `did`.
@@ -155,9 +155,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     ///
     /// - On parameters, opaque type and associated types, add default `Sized` bound if no explicit
     ///   sizedness bounds are present.
-    /// - On traits and trait aliases, add default `MetaSized` supertrait if no explicit sizedness
+    /// - On traits and trait aliases, add default `SizeOfVal` supertrait if no explicit sizedness
     ///   bounds are present.
-    /// - On parameters, opaque type, associated types and trait aliases, add a `MetaSized` bound if
+    /// - On parameters, opaque type, associated types and trait aliases, add a `SizeOfVal` bound if
     ///   a `?Sized` bound is present.
     pub(crate) fn add_implicit_sizedness_bounds(
         &self,
@@ -174,7 +174,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             return;
         }
 
-        let meta_sized_did = tcx.require_lang_item(hir::LangItem::MetaSized, span);
+        let size_of_val_did = tcx.require_lang_item(hir::LangItem::SizeOfVal, span);
         let pointee_sized_did = tcx.require_lang_item(hir::LangItem::PointeeSized, span);
 
         // If adding sizedness bounds to a trait, then there are some relevant early exits
@@ -210,18 +210,18 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let collected = collect_sizedness_bounds(tcx, hir_bounds, context, span);
         if (collected.sized.maybe || collected.sized.negative)
             && !collected.sized.positive
-            && !collected.meta_sized.any()
+            && !collected.size_of_val.any()
             && !collected.pointee_sized.any()
         {
-            // `?Sized` is equivalent to `MetaSized` (but only add the bound if there aren't any
+            // `?Sized` is equivalent to `SizeOfVal` (but only add the bound if there aren't any
             // other explicit ones) - this can happen for trait aliases as well as bounds.
-            add_trait_bound(tcx, bounds, self_ty, meta_sized_did, span);
+            add_trait_bound(tcx, bounds, self_ty, size_of_val_did, span);
         } else if !collected.any() {
             match context {
                 ImpliedBoundsContext::TraitDef(..) => {
                     // If there are no explicit sizedness bounds on a trait then add a default
-                    // `MetaSized` supertrait.
-                    add_trait_bound(tcx, bounds, self_ty, meta_sized_did, span);
+                    // `SizeOfVal` supertrait.
+                    add_trait_bound(tcx, bounds, self_ty, size_of_val_did, span);
                 }
                 ImpliedBoundsContext::TyParam(..)
                 | ImpliedBoundsContext::AssociatedTypeOrImplTrait => {

compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs

@@ -92,14 +92,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         // FIXME(sized-hierarchy): https://github.com/rust-lang/rust/pull/142712#issuecomment-3013231794
         debug!(?user_written_bounds, ?elaborated_trait_bounds);
-        let meta_sized_did = tcx.require_lang_item(LangItem::MetaSized, span);
-        // Don't strip out `MetaSized` when the user wrote it explicitly, only when it was
+        let size_of_val_did = tcx.require_lang_item(LangItem::SizeOfVal, span);
+        // Don't strip out `SizeOfVal` when the user wrote it explicitly, only when it was
         // elaborated
-        if user_written_bounds
-            .iter()
-            .all(|(clause, _)| clause.as_trait_clause().map(|p| p.def_id()) != Some(meta_sized_did))
-        {
-            elaborated_trait_bounds.retain(|(pred, _)| pred.def_id() != meta_sized_did);
+        if user_written_bounds.iter().all(|(clause, _)| {
+            clause.as_trait_clause().map(|p| p.def_id()) != Some(size_of_val_did)
+        }) {
+            elaborated_trait_bounds.retain(|(pred, _)| pred.def_id() != size_of_val_did);
         }
         debug!(?user_written_bounds, ?elaborated_trait_bounds);
 

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -62,7 +62,7 @@ use crate::{NoVariantNamed, check_c_variadic_abi};
 #[derive(Clone, Copy)]
 pub(crate) enum ImpliedBoundsContext<'tcx> {
     /// An implied bound is added to a trait definition (i.e. a new supertrait), used when adding
-    /// a default `MetaSized` supertrait
+    /// a default `SizeOfVal` supertrait
     TraitDef(LocalDefId),
     /// An implied bound is added to a type parameter
     TyParam(LocalDefId, &'tcx [hir::WherePredicate<'tcx>]),

compiler/rustc_lint/src/multiple_supertrait_upcastable.rs

@@ -47,7 +47,7 @@ impl<'tcx> LateLintPass<'tcx> for MultipleSupertraitUpcastable {
                 .explicit_super_predicates_of(def_id)
                 .iter_identity_copied()
                 .filter_map(|(pred, _)| pred.as_trait_clause())
-                .filter(|pred| !cx.tcx.is_lang_item(pred.def_id(), hir::LangItem::MetaSized))
+                .filter(|pred| !cx.tcx.is_lang_item(pred.def_id(), hir::LangItem::SizeOfVal))
                 .filter(|pred| !cx.tcx.is_default_trait(pred.def_id()));
             if direct_super_traits_iter.count() > 1 {
                 cx.emit_span_lint(

compiler/rustc_middle/src/ty/context.rs

@@ -990,7 +990,7 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     pub fn is_sizedness_trait(self, def_id: DefId) -> bool {
-        matches!(self.as_lang_item(def_id), Some(LangItem::Sized | LangItem::MetaSized))
+        matches!(self.as_lang_item(def_id), Some(LangItem::Sized | LangItem::SizeOfVal))
     }
 
     /// Returns a range of the start/end indices specified with the