feature/passes: add rustc_non_const_sized

While there are no non-`const Sized` types in the language, this testing
attribute will make it possible to force this for testing purposes.

Author: davidtwco

compiler/rustc_feature/src/builtin_attrs.rs

@@ -1020,6 +1020,10 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         rustc_force_inline, Normal, template!(Word, NameValueStr: "reason"), WarnFollowing, EncodeCrossCrate::Yes,
         "#[rustc_force_inline] forces a free function to be inlined"
     ),
+    rustc_attr!(
+        rustc_non_const_sized, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::Yes,
+        "#[rustc_non_const_sized] forces a type to not implement `const {Meta,Pointee,}Sized` for testing"
+    ),
 
     // ==========================================================================
     // Internal attributes, Testing:

compiler/rustc_passes/messages.ftl

@@ -688,6 +688,10 @@ passes_rustc_lint_opt_ty =
     `#[rustc_lint_opt_ty]` should be applied to a struct
     .label = not a struct
 
+passes_rustc_non_const_sized =
+    attribute should be applied to a struct or enum
+    .label = not an struct or enum
+
 passes_rustc_pub_transparent =
     attribute should be applied to `#[repr(transparent)]` types
     .label = not a `#[repr(transparent)]` type

compiler/rustc_passes/src/check_attr.rs

@@ -218,6 +218,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::rustc_has_incoherent_inherent_impls, ..] => {
                             self.check_has_incoherent_inherent_impls(attr, span, target)
                         }
+                        [sym::rustc_non_const_sized, ..] => {
+                            self.check_rustc_non_const_sized(span, target)
+                        }
                         [sym::ffi_pure, ..] => self.check_ffi_pure(attr.span(), attrs, target),
                         [sym::ffi_const, ..] => self.check_ffi_const(attr.span(), target),
                         [sym::link_ordinal, ..] => self.check_link_ordinal(attr, span, target),
@@ -2600,6 +2603,19 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
+    /// `#[rustc_non_const_sized]` is a testing attribute for forcing a type to only be `Sized`,
+    /// not `const Sized` (which almost all types implement) - it should only be applied to structs
+    /// or enums. This isn't equivalent to `!const Sized` or anything like that, it just means that
+    /// there isn't a `impl const Sized for T`, only `impl Sized for T` in the compiler.
+    fn check_rustc_non_const_sized(&self, span: Span, target: Target) {
+        match target {
+            Target::Struct | Target::Enum => (),
+            _ => {
+                self.dcx().emit_err(errors::RustcNonConstSized { attr_span: span });
+            }
+        }
+    }
+
     /// Checks if `#[autodiff]` is applied to an item other than a function item.
     fn check_autodiff(&self, _hir_id: HirId, _attr: &Attribute, span: Span, target: Target) {
         debug!("check_autodiff");

compiler/rustc_passes/src/errors.rs

@@ -690,6 +690,13 @@ pub(crate) struct RustcForceInline {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_rustc_non_const_sized)]
+pub(crate) struct RustcNonConstSized {
+    #[primary_span]
+    pub attr_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_rustc_force_inline_coro)]
 pub(crate) struct RustcForceInlineCoro {

compiler/rustc_span/src/symbol.rs

@@ -1785,6 +1785,7 @@ symbols! {
         rustc_never_returns_null_ptr,
         rustc_never_type_options,
         rustc_no_mir_inline,
+        rustc_non_const_sized,
         rustc_nonnull_optimization_guaranteed,
         rustc_nounwind,
         rustc_object_lifetime_default,