Add lint against (some) interior mutable consts

compiler/rustc_codegen_cranelift/patches/0027-stdlib-128bit-atomic-operations.patch

@@ -37,7 +37,7 @@ diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
 index bf2b6d59f88..d5ccce03bbf 100644
 --- a/library/core/src/sync/atomic.rs
 +++ b/library/core/src/sync/atomic.rs
-@@ -3585,44 +3585,6 @@ pub const fn as_ptr(&self) -> *mut $int_type {
+@@ -3585,46 +3585,6 @@ pub const fn as_ptr(&self) -> *mut $int_type {
      8,
      u64 AtomicU64
  }
@@ -54,6 +54,7 @@ index bf2b6d59f88..d5ccce03bbf 100644
 -    rustc_const_unstable(feature = "integer_atomics", issue = "99069"),
 -    rustc_const_unstable(feature = "integer_atomics", issue = "99069"),
 -    rustc_diagnostic_item = "AtomicI128",
+-    cfg_attr(not(bootstrap), rustc_significant_interior_mutable_type),
 -    "i128",
 -    "#![feature(integer_atomics)]\n\n",
 -    atomic_min, atomic_max,
@@ -73,6 +74,7 @@ index bf2b6d59f88..d5ccce03bbf 100644
 -    rustc_const_unstable(feature = "integer_atomics", issue = "99069"),
 -    rustc_const_unstable(feature = "integer_atomics", issue = "99069"),
 -    rustc_diagnostic_item = "AtomicU128",
+-    cfg_attr(not(bootstrap), rustc_significant_interior_mutable_type),
 -    "u128",
 -    "#![feature(integer_atomics)]\n\n",
 -    atomic_umin, atomic_umax,

compiler/rustc_feature/src/builtin_attrs.rs

@@ -896,6 +896,11 @@ pub static 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 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_lint/messages.ftl

@@ -426,6 +426,14 @@ lint_incomplete_include =
 
 lint_inner_macro_attribute_unstable = inner macro attributes are unstable
 
+lint_interior_mutable_consts = interior mutability in `const` item have no effect to the `const` item itself
+    .label = `{$ty_name}` is an interior mutable type
+    .temporary = each usage of a `const` item creates a new temporary
+    .never_original = only the temporaries and never the original `const` item `{$const_name}` will be modified
+    .suggestion_inline_const = for use as an initializer, consider using an inline-const `const {"{"} /* ... */ {"}"}` at the usage site instead
+    .suggestion_static = for a shared instance of `{$const_name}`, consider using a `static` item instead
+    .suggestion_allow = alternatively consider allowing the lint
+
 lint_invalid_asm_label_binary = avoid using labels containing only the digits `0` and `1` in inline assembly
     .label = use a different label that doesn't start with `0` or `1`
     .help = start numbering with `2` instead

compiler/rustc_lint/src/lints.rs

@@ -1874,6 +1874,55 @@ pub(crate) enum UnpredictableFunctionPointerComparisonsSuggestion<'a, 'tcx> {
     },
 }
 
+#[derive(LintDiagnostic)]
+#[diag(lint_interior_mutable_consts)]
+#[note(lint_temporary)]
+#[note(lint_never_original)]
+#[help(lint_suggestion_inline_const)]
+pub(crate) struct InteriorMutableConstsDiag {
+    pub ty_name: Ident,
+    pub const_name: Ident,
+    #[label]
+    pub ty_span: Span,
+    #[subdiagnostic]
+    pub sugg_static: InteriorMutableConstsSuggestionStatic,
+    #[subdiagnostic]
+    pub sugg_allow: InteriorMutableConstsSuggestionAllow,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum InteriorMutableConstsSuggestionStatic {
+    #[suggestion(
+        lint_suggestion_static,
+        code = "{before}static ",
+        style = "verbose",
+        applicability = "maybe-incorrect"
+    )]
+    Spanful {
+        #[primary_span]
+        const_: Span,
+        before: &'static str,
+    },
+    #[help(lint_suggestion_static)]
+    Spanless,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum InteriorMutableConstsSuggestionAllow {
+    #[suggestion(
+        lint_suggestion_allow,
+        code = "#[allow(interior_mutable_consts)] ",
+        style = "verbose",
+        applicability = "maybe-incorrect"
+    )]
+    Spanful {
+        #[primary_span]
+        span: Span,
+    },
+    #[help(lint_suggestion_allow)]
+    Spanless,
+}
+
 pub(crate) struct ImproperCTypes<'a> {
     pub ty: Ty<'a>,
     pub desc: &'a str,

compiler/rustc_lint/src/types.rs

@@ -23,10 +23,11 @@ mod improper_ctypes;
 use crate::lints::{
     AmbiguousWidePointerComparisons, AmbiguousWidePointerComparisonsAddrMetadataSuggestion,
     AmbiguousWidePointerComparisonsAddrSuggestion, AtomicOrderingFence, AtomicOrderingLoad,
-    AtomicOrderingStore, ImproperCTypes, InvalidAtomicOrderingDiag, InvalidNanComparisons,
-    InvalidNanComparisonsSuggestion, UnpredictableFunctionPointerComparisons,
-    UnpredictableFunctionPointerComparisonsSuggestion, UnusedComparisons, UsesPowerAlignment,
-    VariantSizeDifferencesDiag,
+    AtomicOrderingStore, ImproperCTypes, InteriorMutableConstsDiag,
+    InteriorMutableConstsSuggestionAllow, InteriorMutableConstsSuggestionStatic,
+    InvalidAtomicOrderingDiag, InvalidNanComparisons, InvalidNanComparisonsSuggestion,
+    UnpredictableFunctionPointerComparisons, UnpredictableFunctionPointerComparisonsSuggestion,
+    UnusedComparisons, UsesPowerAlignment, VariantSizeDifferencesDiag,
 };
 use crate::{LateContext, LateLintPass, LintContext, fluent_generated as fluent};
 
@@ -198,6 +199,47 @@ declare_lint! {
     "detects unpredictable function pointer comparisons"
 }
 
+declare_lint! {
+    /// The `interior_mutable_consts` lint detects instance where
+    /// const-items have a interior mutable type, which silently does nothing.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// use std::sync::Once;
+    ///
+    /// // SAFETY: should only be call once
+    /// unsafe extern "C" fn ffi_init() { /* ... */ }
+    ///
+    /// const A: Once = Once::new(); // using `B` will always creates temporaries and
+    ///                              // never modify it-self on use, should be a
+    ///                              // static-item instead
+    ///
+    /// fn init() {
+    ///     A.call_once(|| unsafe {
+    ///         ffi_init();  // unsound, as the `call_once` is on a temporary
+    ///                      // and not on a shared variable
+    ///     })
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Using a const-item with an interior mutable type has no effect as const-item
+    /// are essentially inlined wherever they are used, meaning that they are copied
+    /// directly into the relevant context when used rendering modification through
+    /// interior mutability ineffective across usage of that const-item.
+    ///
+    /// The current implementation of this lint only warns on significant `std` and
+    /// `core` interior mutable types, like `Once`, `AtomicI32`, ... this is done out
+    /// of prudence and may be extended in the future.
+    INTERIOR_MUTABLE_CONSTS,
+    Warn,
+    "detects const items with interior mutable type",
+}
+
 #[derive(Copy, Clone, Default)]
 pub(crate) struct TypeLimits {
     /// Id of the last visited negated expression
@@ -211,7 +253,8 @@ impl_lint_pass!(TypeLimits => [
     OVERFLOWING_LITERALS,
     INVALID_NAN_COMPARISONS,
     AMBIGUOUS_WIDE_POINTER_COMPARISONS,
-    UNPREDICTABLE_FUNCTION_POINTER_COMPARISONS
+    UNPREDICTABLE_FUNCTION_POINTER_COMPARISONS,
+    INTERIOR_MUTABLE_CONSTS,
 ]);
 
 impl TypeLimits {
@@ -687,6 +730,48 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
             })
         }
     }
+
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
+        if let hir::ItemKind::Const(ty, _generics, _body_id) = item.kind
+            && let hir::TyKind::Path(ref qpath) = ty.kind
+            && let Some(def_id) = cx.qpath_res(qpath, ty.hir_id).opt_def_id()
+            && cx.tcx.has_attr(def_id, sym::rustc_significant_interior_mutable_type)
+            && let Some(ty_name) = cx.tcx.opt_item_ident(def_id)
+        {
+            let (sugg_static, sugg_allow) = if let Some(vis_span) =
+                item.vis_span.find_ancestor_inside(item.span)
+                && item.span.can_be_used_for_suggestions()
+                && vis_span.can_be_used_for_suggestions()
+            {
+                (
+                    InteriorMutableConstsSuggestionStatic::Spanful {
+                        const_: item.vis_span.between(item.ident.span),
+                        before: if !vis_span.is_empty() { " " } else { "" },
+                    },
+                    InteriorMutableConstsSuggestionAllow::Spanful {
+                        span: item.span.shrink_to_lo(),
+                    },
+                )
+            } else {
+                (
+                    InteriorMutableConstsSuggestionStatic::Spanless,
+                    InteriorMutableConstsSuggestionAllow::Spanless,
+                )
+            };
+
+            cx.emit_span_lint(
+                INTERIOR_MUTABLE_CONSTS,
+                item.span,
+                InteriorMutableConstsDiag {
+                    ty_name,
+                    ty_span: ty.span,
+                    const_name: item.ident,
+                    sugg_static,
+                    sugg_allow,
+                },
+            );
+        }
+    }
 }
 
 declare_lint! {

compiler/rustc_passes/src/check_attr.rs

@@ -179,6 +179,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::rustc_as_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_never_returns_null_ptr, ..] => {
                             self.check_applied_to_fn_or_method(hir_id, attr, span, target)
                         }
@@ -1766,6 +1769,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

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

library/core/src/cell.rs

@@ -308,6 +308,7 @@ pub use once::OnceCell;
 #[stable(feature = "rust1", since = "1.0.0")]
 #[repr(transparent)]
 #[rustc_pub_transparent]
+#[cfg_attr(not(bootstrap), rustc_significant_interior_mutable_type)]
 pub struct Cell<T: ?Sized> {
     value: UnsafeCell<T>,
 }
@@ -727,6 +728,7 @@ impl<T, const N: usize> Cell<[T; N]> {
 /// See the [module-level documentation](self) for more.
 #[rustc_diagnostic_item = "RefCell"]
 #[stable(feature = "rust1", since = "1.0.0")]
+#[cfg_attr(not(bootstrap), rustc_significant_interior_mutable_type)]
 pub struct RefCell<T: ?Sized> {
     borrow: Cell<BorrowFlag>,
     // Stores the location of the earliest currently active borrow.
@@ -2072,6 +2074,7 @@ impl<T: ?Sized + fmt::Display> fmt::Display for RefMut<'_, T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 #[repr(transparent)]
 #[rustc_pub_transparent]
+#[cfg_attr(not(bootstrap), rustc_significant_interior_mutable_type)]
 pub struct UnsafeCell<T: ?Sized> {
     value: T,
 }

library/core/src/cell/lazy.rs

@@ -35,6 +35,7 @@ enum State<T, F> {
 /// //   92
 /// ```
 #[stable(feature = "lazy_cell", since = "1.80.0")]
+#[cfg_attr(not(bootstrap), rustc_significant_interior_mutable_type)]
 pub struct LazyCell<T, F = fn() -> T> {
     state: UnsafeCell<State<T, F>>,
 }

library/core/src/cell/once.rs

@@ -32,6 +32,7 @@ use crate::{fmt, mem};
 /// assert!(cell.get().is_some());
 /// ```
 #[stable(feature = "once_cell", since = "1.70.0")]
+#[cfg_attr(not(bootstrap), rustc_significant_interior_mutable_type)]
 pub struct OnceCell<T> {
     // Invariant: written to at most once.
     inner: UnsafeCell<Option<T>>,