Add interior_mutable_consts lint

Author: Urgau

compiler/rustc_lint/messages.ftl

@@ -436,6 +436,14 @@ lint_incomplete_include =
 
 lint_inner_macro_attribute_unstable = inner macro attributes are unstable
 
+lint_interior_mutable_consts = interior mutability in `const` items have no effect on 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_expect = alternatively consider expecting 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

@@ -1940,6 +1940,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_expect: InteriorMutableConstsSuggestionExpect,
+}
+
+#[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 InteriorMutableConstsSuggestionExpect {
+    #[suggestion(
+        lint_suggestion_expect,
+        code = "#[expect(interior_mutable_consts, reason = \"...\")] ",
+        style = "verbose",
+        applicability = "maybe-incorrect"
+    )]
+    Spanful {
+        #[primary_span]
+        span: Span,
+    },
+    #[help(lint_suggestion_expect)]
+    Spanless,
+}
+
 pub(crate) struct ImproperCTypes<'a> {
     pub ty: Ty<'a>,
     pub desc: &'a str,

compiler/rustc_lint/src/types.rs

@@ -26,10 +26,11 @@ use crate::lints::{
     AmbiguousWidePointerComparisons, AmbiguousWidePointerComparisonsAddrMetadataSuggestion,
     AmbiguousWidePointerComparisonsAddrSuggestion, AmbiguousWidePointerComparisonsCastSuggestion,
     AmbiguousWidePointerComparisonsExpectSuggestion, AtomicOrderingFence, AtomicOrderingLoad,
-    AtomicOrderingStore, ImproperCTypes, InvalidAtomicOrderingDiag, InvalidNanComparisons,
-    InvalidNanComparisonsSuggestion, UnpredictableFunctionPointerComparisons,
-    UnpredictableFunctionPointerComparisonsSuggestion, UnusedComparisons, UsesPowerAlignment,
-    VariantSizeDifferencesDiag,
+    AtomicOrderingStore, ImproperCTypes, InteriorMutableConstsDiag,
+    InteriorMutableConstsSuggestionExpect, InteriorMutableConstsSuggestionStatic,
+    InvalidAtomicOrderingDiag, InvalidNanComparisons, InvalidNanComparisonsSuggestion,
+    UnpredictableFunctionPointerComparisons, UnpredictableFunctionPointerComparisonsSuggestion,
+    UnusedComparisons, UsesPowerAlignment, VariantSizeDifferencesDiag,
 };
 use crate::{LateContext, LateLintPass, LintContext, fluent_generated as fluent};
 
@@ -201,6 +202,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 itself 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
@@ -214,7 +256,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 {
@@ -696,6 +739,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(ident, 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_expect) = 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(ident.span),
+                        before: if !vis_span.is_empty() { " " } else { "" },
+                    },
+                    InteriorMutableConstsSuggestionExpect::Spanful {
+                        span: item.span.shrink_to_lo(),
+                    },
+                )
+            } else {
+                (
+                    InteriorMutableConstsSuggestionStatic::Spanless,
+                    InteriorMutableConstsSuggestionExpect::Spanless,
+                )
+            };
+
+            cx.emit_span_lint(
+                INTERIOR_MUTABLE_CONSTS,
+                item.span,
+                InteriorMutableConstsDiag {
+                    ty_name,
+                    ty_span: ty.span,
+                    const_name: ident,
+                    sugg_static,
+                    sugg_expect,
+                },
+            );
+        }
+    }
 }
 
 declare_lint! {

tests/ui/lint/interior-mutable-types-in-consts-not-sync.rs

@@ -0,0 +1,16 @@
+//@ check-pass
+
+use std::cell::{Cell, RefCell, UnsafeCell, LazyCell, OnceCell};
+
+const A: Cell<i32> = Cell::new(0);
+//~^ WARN interior mutability in `const` item
+const B: RefCell<i32> = RefCell::new(0);
+//~^ WARN interior mutability in `const` item
+const C: UnsafeCell<i32> = UnsafeCell::new(0);
+//~^ WARN interior mutability in `const` item
+const D: LazyCell<i32> = LazyCell::new(|| 0);
+//~^ WARN interior mutability in `const` item
+const E: OnceCell<i32> = OnceCell::new();
+//~^ WARN interior mutability in `const` item
+
+fn main() {}

tests/ui/lint/interior-mutable-types-in-consts-not-sync.stderr

@@ -0,0 +1,108 @@
+warning: interior mutability in `const` items have no effect on the `const` item itself
+  --> $DIR/interior-mutable-types-in-consts-not-sync.rs:5:1
+   |
+LL | const A: Cell<i32> = Cell::new(0);
+   | ^^^^^^^^^---------^^^^^^^^^^^^^^^^
+   |          |
+   |          `Cell` is an interior mutable type
+   |
+   = note: each usage of a `const` item creates a new temporary
+   = note: only the temporaries and never the original `const` item `A` will be modified
+   = help: for use as an initializer, consider using an inline-const `const { /* ... */ }` at the usage site instead
+   = note: `#[warn(interior_mutable_consts)]` on by default
+help: for a shared instance of `A`, consider using a `static` item instead
+   |
+LL - const A: Cell<i32> = Cell::new(0);
+LL + static A: Cell<i32> = Cell::new(0);
+   |
+help: alternatively consider expecting the lint
+   |
+LL | #[expect(interior_mutable_consts, reason = "...")] const A: Cell<i32> = Cell::new(0);
+   | ++++++++++++++++++++++++++++++++++++++++++++++++++
+
+warning: interior mutability in `const` items have no effect on the `const` item itself
+  --> $DIR/interior-mutable-types-in-consts-not-sync.rs:7:1
+   |
+LL | const B: RefCell<i32> = RefCell::new(0);
+   | ^^^^^^^^^------------^^^^^^^^^^^^^^^^^^^
+   |          |
+   |          `RefCell` is an interior mutable type
+   |
+   = note: each usage of a `const` item creates a new temporary
+   = note: only the temporaries and never the original `const` item `B` will be modified
+   = help: for use as an initializer, consider using an inline-const `const { /* ... */ }` at the usage site instead
+help: for a shared instance of `B`, consider using a `static` item instead
+   |
+LL - const B: RefCell<i32> = RefCell::new(0);
+LL + static B: RefCell<i32> = RefCell::new(0);
+   |
+help: alternatively consider expecting the lint
+   |
+LL | #[expect(interior_mutable_consts, reason = "...")] const B: RefCell<i32> = RefCell::new(0);
+   | ++++++++++++++++++++++++++++++++++++++++++++++++++
+
+warning: interior mutability in `const` items have no effect on the `const` item itself
+  --> $DIR/interior-mutable-types-in-consts-not-sync.rs:9:1
+   |
+LL | const C: UnsafeCell<i32> = UnsafeCell::new(0);
+   | ^^^^^^^^^---------------^^^^^^^^^^^^^^^^^^^^^^
+   |          |
+   |          `UnsafeCell` is an interior mutable type
+   |
+   = note: each usage of a `const` item creates a new temporary
+   = note: only the temporaries and never the original `const` item `C` will be modified
+   = help: for use as an initializer, consider using an inline-const `const { /* ... */ }` at the usage site instead
+help: for a shared instance of `C`, consider using a `static` item instead
+   |
+LL - const C: UnsafeCell<i32> = UnsafeCell::new(0);
+LL + static C: UnsafeCell<i32> = UnsafeCell::new(0);
+   |
+help: alternatively consider expecting the lint
+   |
+LL | #[expect(interior_mutable_consts, reason = "...")] const C: UnsafeCell<i32> = UnsafeCell::new(0);
+   | ++++++++++++++++++++++++++++++++++++++++++++++++++
+
+warning: interior mutability in `const` items have no effect on the `const` item itself
+  --> $DIR/interior-mutable-types-in-consts-not-sync.rs:11:1
+   |
+LL | const D: LazyCell<i32> = LazyCell::new(|| 0);
+   | ^^^^^^^^^-------------^^^^^^^^^^^^^^^^^^^^^^^
+   |          |
+   |          `LazyCell` is an interior mutable type
+   |
+   = note: each usage of a `const` item creates a new temporary
+   = note: only the temporaries and never the original `const` item `D` will be modified
+   = help: for use as an initializer, consider using an inline-const `const { /* ... */ }` at the usage site instead
+help: for a shared instance of `D`, consider using a `static` item instead
+   |
+LL - const D: LazyCell<i32> = LazyCell::new(|| 0);
+LL + static D: LazyCell<i32> = LazyCell::new(|| 0);
+   |
+help: alternatively consider expecting the lint
+   |
+LL | #[expect(interior_mutable_consts, reason = "...")] const D: LazyCell<i32> = LazyCell::new(|| 0);
+   | ++++++++++++++++++++++++++++++++++++++++++++++++++
+
+warning: interior mutability in `const` items have no effect on the `const` item itself
+  --> $DIR/interior-mutable-types-in-consts-not-sync.rs:13:1
+   |
+LL | const E: OnceCell<i32> = OnceCell::new();
+   | ^^^^^^^^^-------------^^^^^^^^^^^^^^^^^^^
+   |          |
+   |          `OnceCell` is an interior mutable type
+   |
+   = note: each usage of a `const` item creates a new temporary
+   = note: only the temporaries and never the original `const` item `E` will be modified
+   = help: for use as an initializer, consider using an inline-const `const { /* ... */ }` at the usage site instead
+help: for a shared instance of `E`, consider using a `static` item instead
+   |
+LL - const E: OnceCell<i32> = OnceCell::new();
+LL + static E: OnceCell<i32> = OnceCell::new();
+   |
+help: alternatively consider expecting the lint
+   |
+LL | #[expect(interior_mutable_consts, reason = "...")] const E: OnceCell<i32> = OnceCell::new();
+   | ++++++++++++++++++++++++++++++++++++++++++++++++++
+
+warning: 5 warnings emitted
+

tests/ui/lint/interior-mutable-types-in-consts.rs

@@ -0,0 +1,44 @@
+//@ check-pass
+
+#![feature(reentrant_lock)]
+
+use std::sync::{Once, Barrier, Condvar, LazyLock, Mutex, OnceLock, ReentrantLock, RwLock};
+use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicI32, AtomicU32};
+
+const A: Once = Once::new();
+//~^ WARN interior mutability in `const` items
+const B: Barrier = Barrier::new(0);
+//~^ WARN interior mutability in `const` items
+const C: Condvar = Condvar::new();
+//~^ WARN interior mutability in `const` items
+const D: LazyLock<i32> = LazyLock::new(|| 0);
+//~^ WARN interior mutability in `const` items
+const E: Mutex<i32> = Mutex::new(0);
+//~^ WARN interior mutability in `const` items
+const F: OnceLock<i32> = OnceLock::new();
+//~^ WARN interior mutability in `const` items
+const G: ReentrantLock<i32> = ReentrantLock::new(0);
+//~^ WARN interior mutability in `const` items
+const H: RwLock<i32> = RwLock::new(0);
+//~^ WARN interior mutability in `const` items
+const I: AtomicBool = AtomicBool::new(false);
+//~^ WARN interior mutability in `const` items
+const J: AtomicPtr<i32> = AtomicPtr::new(std::ptr::null_mut());
+//~^ WARN interior mutability in `const` items
+const K: AtomicI32 = AtomicI32::new(0);
+//~^ WARN interior mutability in `const` items
+const L: AtomicU32 = AtomicU32::new(0);
+//~^ WARN interior mutability in `const` items
+
+pub(crate) const X: Once = Once::new();
+//~^ WARN interior mutability in `const` items
+
+fn main() {
+    const Z: Once = Once::new();
+    //~^ WARN interior mutability in `const` items
+}
+
+struct S;
+impl S {
+    const Z: Once = Once::new(); // not a const-item
+}