Add #[rustc_significant_interior_mutable_type] attribute

Author: Urgau

compiler/rustc_feature/src/builtin_attrs.rs

@@ -887,6 +887,11 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         EncodeCrossCrate::Yes,
         "#[rustc_never_returns_null_ptr] is used to mark functions returning non-null pointers."
     ),
+    rustc_attr!(
+        rustc_significant_interior_mutable_type, Normal, template!(Word), ErrorFollowing,
+        EncodeCrossCrate::Yes,
+        "#[rustc_significant_interior_mutable_type] is used to mark type that are significant interiormutable types."
+    ),
     rustc_attr!(
         rustc_coherence_is_core, AttributeType::CrateLevel, template!(Word), ErrorFollowing, EncodeCrossCrate::No,
         "#![rustc_coherence_is_core] allows inherent methods on builtin types, only intended to be used in `core`."

compiler/rustc_passes/src/check_attr.rs

@@ -164,6 +164,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 [sym::rustc_never_returns_null_ptr, ..] => {
                     self.check_applied_to_fn_or_method(hir_id, attr, span, target)
                 }
+                [sym::rustc_significant_interior_mutable_type, ..] => {
+                    self.check_rustc_significant_interior_mutable_type(attr, span, target)
+                }
                 [sym::rustc_legacy_const_generics, ..] => {
                     self.check_rustc_legacy_const_generics(hir_id, attr, span, target, item)
                 }
@@ -1628,6 +1631,24 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
+    /// Checks if `#[rustc_significant_interior_mutable_type]` is applied to a struct, enum, union, or trait.
+    fn check_rustc_significant_interior_mutable_type(
+        &self,
+        attr: &Attribute,
+        span: Span,
+        target: Target,
+    ) {
+        match target {
+            Target::Struct | Target::Enum | Target::Union => {}
+            _ => {
+                self.dcx().emit_err(errors::AttrShouldBeAppliedToStructEnum {
+                    attr_span: attr.span,
+                    span,
+                });
+            }
+        }
+    }
+
     /// Checks if the attribute is applied to a trait.
     fn check_must_be_applied_to_trait(&self, attr: &Attribute, span: Span, target: Target) {
         match target {

compiler/rustc_passes/src/errors.rs

@@ -96,6 +96,15 @@ pub(crate) struct AttrShouldBeAppliedToFn {
     pub on_crate: bool,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_should_be_applied_to_struct_enum)]
+pub(crate) struct AttrShouldBeAppliedToStructEnum {
+    #[primary_span]
+    pub attr_span: Span,
+    #[label]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_should_be_applied_to_fn, code = E0739)]
 pub(crate) struct TrackedCallerWrongLocation {

compiler/rustc_span/src/symbol.rs

@@ -1740,6 +1740,7 @@ symbols! {
         rustc_runtime,
         rustc_safe_intrinsic,
         rustc_serialize,
+        rustc_significant_interior_mutable_type,
         rustc_skip_during_method_dispatch,
         rustc_specialization_trait,
         rustc_std_internal_symbol,