Add #[rustc_significant_interior_mutable_type] attribute

Author: Urgau

compiler/rustc_feature/src/builtin_attrs.rs

@@ -922,6 +922,10 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         rustc_no_implicit_autorefs, AttributeType::Normal, template!(Word), ErrorFollowing, EncodeCrossCrate::Yes,
         "`#[rustc_no_implicit_autorefs]` is used to mark functions for which an autoref to the dereference of a raw pointer should not be used as an argument."
     ),
+    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 interior mutable 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

@@ -182,6 +182,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::rustc_no_implicit_autorefs, ..] => {
                             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_never_returns_null_ptr, ..] => {
                             self.check_applied_to_fn_or_method(hir_id, attr, span, target)
                         }
@@ -1823,6 +1826,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 that the `#[rustc_lint_opt_ty]` attribute is only applied to a struct.
     fn check_rustc_lint_opt_ty(&self, attr: &Attribute, span: Span, target: Target) {
         match target {

compiler/rustc_passes/src/errors.rs

@@ -108,6 +108,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

@@ -1849,6 +1849,7 @@ symbols! {
         rustc_regions,
         rustc_reservation_impl,
         rustc_serialize,
+        rustc_significant_interior_mutable_type,
         rustc_skip_during_method_dispatch,
         rustc_specialization_trait,
         rustc_std_internal_symbol,