Skip to content

Commit da4de38

Browse files
UrgauUrgau
committed
Add interior_mutable_consts lint
1 parent ce7c92d commit da4de38

8 files changed

+626
-3
lines changed

‎compiler/rustc_lint/messages.ftl‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -420,6 +420,14 @@ lint_incomplete_include =
420420
421421
lint_inner_macro_attribute_unstable = inner macro attributes are unstable
422422
423+
lint_interior_mutable_consts = interior mutability in `const` item have no effect to the `const` item it-self
424+
.label = `{$ty_name}` is an interior mutable type
425+
.temporary = each usage of a `const` item creates a new temporary
426+
.never_original = only the temporaries and never the original `const` item `{$const_name}` will be modified
427+
.suggestion_inline_const = for use as an initializer, consider using an inline-const `const {"{"} /* ... */ {"}"}` at the usage site instead
428+
.suggestion_static = for a shared instance of `{$const_name}`, consider using a `static` item instead
429+
.suggestion_allow = alternatively consider allowing the lint
430+
423431
lint_invalid_asm_label_binary = avoid using labels containing only the digits `0` and `1` in inline assembly
424432
.label = use a different label that doesn't start with `0` or `1`
425433
.help = start numbering with `2` instead

‎compiler/rustc_lint/src/lints.rs‎

Lines changed: 49 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1806,6 +1806,55 @@ pub(crate) enum AmbiguousWidePointerComparisonsAddrSuggestion<'a> {
18061806
},
18071807
}
18081808

1809+
#[derive(LintDiagnostic)]
1810+
#[diag(lint_interior_mutable_consts)]
1811+
#[note(lint_temporary)]
1812+
#[note(lint_never_original)]
1813+
#[help(lint_suggestion_inline_const)]
1814+
pub(crate) struct InteriorMutableConstsDiag {
1815+
pub ty_name: Ident,
1816+
pub const_name: Ident,
1817+
#[label]
1818+
pub ty_span: Span,
1819+
#[subdiagnostic]
1820+
pub sugg_static: InteriorMutableConstsSuggestionStatic,
1821+
#[subdiagnostic]
1822+
pub sugg_allow: InteriorMutableConstsSuggestionAllow,
1823+
}
1824+
1825+
#[derive(Subdiagnostic)]
1826+
pub(crate) enum InteriorMutableConstsSuggestionStatic {
1827+
#[suggestion(
1828+
lint_suggestion_static,
1829+
code = "{before}static ",
1830+
style = "verbose",
1831+
applicability = "maybe-incorrect"
1832+
)]
1833+
Spanful {
1834+
#[primary_span]
1835+
const_: Span,
1836+
before: &'static str,
1837+
},
1838+
#[help(lint_suggestion_static)]
1839+
Spanless,
1840+
}
1841+
1842+
#[derive(Subdiagnostic)]
1843+
pub(crate) enum InteriorMutableConstsSuggestionAllow {
1844+
#[suggestion(
1845+
lint_suggestion_allow,
1846+
code = "#[allow(interior_mutable_consts)] ",
1847+
style = "verbose",
1848+
applicability = "maybe-incorrect"
1849+
)]
1850+
Spanful {
1851+
#[primary_span]
1852+
span: Span,
1853+
},
1854+
#[help(lint_suggestion_allow)]
1855+
Spanless,
1856+
}
1857+
18091858
pub(crate) struct ImproperCTypes<'a> {
18101859
pub ty: Ty<'a>,
18111860
pub desc: &'a str,

‎compiler/rustc_lint/src/types.rs‎

Lines changed: 75 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -23,8 +23,10 @@ mod improper_ctypes;
2323
use crate::lints::{
2424
AmbiguousWidePointerComparisons, AmbiguousWidePointerComparisonsAddrMetadataSuggestion,
2525
AmbiguousWidePointerComparisonsAddrSuggestion, AtomicOrderingFence, AtomicOrderingLoad,
26-
AtomicOrderingStore, ImproperCTypes, InvalidAtomicOrderingDiag, InvalidNanComparisons,
27-
InvalidNanComparisonsSuggestion, UnusedComparisons, VariantSizeDifferencesDiag,
26+
AtomicOrderingStore, ImproperCTypes, InteriorMutableConstsDiag,
27+
InteriorMutableConstsSuggestionAllow, InteriorMutableConstsSuggestionStatic,
28+
InvalidAtomicOrderingDiag, InvalidNanComparisons, InvalidNanComparisonsSuggestion,
29+
UnusedComparisons, VariantSizeDifferencesDiag,
2830
};
2931
use crate::{LateContext, LateLintPass, LintContext, fluent_generated as fluent};
3032

@@ -167,6 +169,37 @@ declare_lint! {
167169
"detects ambiguous wide pointer comparisons"
168170
}
169171

172+
declare_lint! {
173+
/// The `interior_mutable_consts` lint detects instance where
174+
/// const-items have a interior mutable type, which silently does nothing.
175+
///
176+
/// ### Example
177+
///
178+
/// ```
179+
/// use std::sync::Once;
180+
///
181+
/// const A: Once = Once::new(); // using `B` will always duplicate `B` and never
182+
/// // modify it-self as it's a const-item and not a
183+
/// // static-item
184+
/// ```
185+
///
186+
/// {{produces}}
187+
///
188+
/// ### Explanation
189+
///
190+
/// Using a const-item with an interior mutable type has no effect as const-item
191+
/// are essentially inlined wherever they are used, meaning that they are copied
192+
/// directly into the relevant context when used rendering modification through
193+
/// interior mutability ineffective across usage of that const-item.
194+
///
195+
/// The current implementation of this lint only warns on significant `std` and
196+
/// `core` interior mutable types, like `Once`, `AtomicI32`, ... this is done out
197+
/// of prudence and may be extended in the future.
198+
INTERIOR_MUTABLE_CONSTS,
199+
Warn,
200+
"detects const items with interior mutable type",
201+
}
202+
170203
#[derive(Copy, Clone)]
171204
pub(crate) struct TypeLimits {
172205
/// Id of the last visited negated expression
@@ -179,7 +212,8 @@ impl_lint_pass!(TypeLimits => [
179212
UNUSED_COMPARISONS,
180213
OVERFLOWING_LITERALS,
181214
INVALID_NAN_COMPARISONS,
182-
AMBIGUOUS_WIDE_POINTER_COMPARISONS
215+
AMBIGUOUS_WIDE_POINTER_COMPARISONS,
216+
INTERIOR_MUTABLE_CONSTS,
183217
]);
184218

185219
impl TypeLimits {
@@ -513,6 +547,44 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
513547
})
514548
}
515549
}
550+
551+
fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
552+
if let hir::ItemKind::Const(ty, _generics, _body_id) = item.kind
553+
&& let hir::TyKind::Path(ref qpath) = ty.kind
554+
&& let Some(def_id) = cx.qpath_res(qpath, ty.hir_id).opt_def_id()
555+
&& cx.tcx.has_attr(def_id, sym::rustc_significant_interior_mutable_type)
556+
&& let Some(ty_name) = cx.tcx.opt_item_ident(def_id)
557+
{
558+
let (sugg_static, sugg_allow) = if let Some(vis_span) =
559+
item.vis_span.find_ancestor_inside(item.span)
560+
&& item.span.can_be_used_for_suggestions()
561+
&& vis_span.can_be_used_for_suggestions()
562+
{
563+
(
564+
InteriorMutableConstsSuggestionStatic::Spanful {
565+
const_: item.vis_span.between(item.ident.span),
566+
before: if !vis_span.is_empty() { " " } else { "" },
567+
},
568+
InteriorMutableConstsSuggestionAllow::Spanful {
569+
span: item.span.shrink_to_lo(),
570+
},
571+
)
572+
} else {
573+
(
574+
InteriorMutableConstsSuggestionStatic::Spanless,
575+
InteriorMutableConstsSuggestionAllow::Spanless,
576+
)
577+
};
578+
579+
cx.emit_span_lint(INTERIOR_MUTABLE_CONSTS, item.span, InteriorMutableConstsDiag {
580+
ty_name,
581+
ty_span: ty.span,
582+
const_name: item.ident,
583+
sugg_static,
584+
sugg_allow,
585+
});
586+
}
587+
}
516588
}
517589

518590
declare_lint! {

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

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
//@ check-pass
2+
3+
use std::cell::{Cell, RefCell, UnsafeCell, LazyCell, OnceCell};
4+
5+
const A: Cell<i32> = Cell::new(0);
6+
//~^ WARN interior mutability in `const` item
7+
const B: RefCell<i32> = RefCell::new(0);
8+
//~^ WARN interior mutability in `const` item
9+
const C: UnsafeCell<i32> = UnsafeCell::new(0);
10+
//~^ WARN interior mutability in `const` item
11+
const D: LazyCell<i32> = LazyCell::new(|| 0);
12+
//~^ WARN interior mutability in `const` item
13+
const E: OnceCell<i32> = OnceCell::new();
14+
//~^ WARN interior mutability in `const` item
15+
16+
fn main() {}

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

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,103 @@
1+
warning: interior mutability in `const` item have no effect to the `const` item it-self
2+
--> $DIR/interior-mutable-types-in-consts-not-sync.rs:5:1
3+
|
4+
LL | const A: Cell<i32> = Cell::new(0);
5+
| ^^^^^^^^^---------^^^^^^^^^^^^^^^^
6+
| |
7+
| `Cell` is an interior mutable type
8+
|
9+
= note: each usage of a `const` item creates a new temporary
10+
= note: only the temporaries and never the original `const` item `A` will be modified
11+
= help: for use as an initializer, consider using an inline-const `const { /* ... */ }` at the usage site instead
12+
= note: `#[warn(interior_mutable_consts)]` on by default
13+
help: for a shared instance of `A`, consider using a `static` item instead
14+
|
15+
LL | static A: Cell<i32> = Cell::new(0);
16+
| ~~~~~~
17+
help: alternatively consider allowing the lint
18+
|
19+
LL | #[allow(interior_mutable_consts)] const A: Cell<i32> = Cell::new(0);
20+
| +++++++++++++++++++++++++++++++++
21+
22+
warning: interior mutability in `const` item have no effect to the `const` item it-self
23+
--> $DIR/interior-mutable-types-in-consts-not-sync.rs:7:1
24+
|
25+
LL | const B: RefCell<i32> = RefCell::new(0);
26+
| ^^^^^^^^^------------^^^^^^^^^^^^^^^^^^^
27+
| |
28+
| `RefCell` is an interior mutable type
29+
|
30+
= note: each usage of a `const` item creates a new temporary
31+
= note: only the temporaries and never the original `const` item `B` will be modified
32+
= help: for use as an initializer, consider using an inline-const `const { /* ... */ }` at the usage site instead
33+
help: for a shared instance of `B`, consider using a `static` item instead
34+
|
35+
LL | static B: RefCell<i32> = RefCell::new(0);
36+
| ~~~~~~
37+
help: alternatively consider allowing the lint
38+
|
39+
LL | #[allow(interior_mutable_consts)] const B: RefCell<i32> = RefCell::new(0);
40+
| +++++++++++++++++++++++++++++++++
41+
42+
warning: interior mutability in `const` item have no effect to the `const` item it-self
43+
--> $DIR/interior-mutable-types-in-consts-not-sync.rs:9:1
44+
|
45+
LL | const C: UnsafeCell<i32> = UnsafeCell::new(0);
46+
| ^^^^^^^^^---------------^^^^^^^^^^^^^^^^^^^^^^
47+
| |
48+
| `UnsafeCell` is an interior mutable type
49+
|
50+
= note: each usage of a `const` item creates a new temporary
51+
= note: only the temporaries and never the original `const` item `C` will be modified
52+
= help: for use as an initializer, consider using an inline-const `const { /* ... */ }` at the usage site instead
53+
help: for a shared instance of `C`, consider using a `static` item instead
54+
|
55+
LL | static C: UnsafeCell<i32> = UnsafeCell::new(0);
56+
| ~~~~~~
57+
help: alternatively consider allowing the lint
58+
|
59+
LL | #[allow(interior_mutable_consts)] const C: UnsafeCell<i32> = UnsafeCell::new(0);
60+
| +++++++++++++++++++++++++++++++++
61+
62+
warning: interior mutability in `const` item have no effect to the `const` item it-self
63+
--> $DIR/interior-mutable-types-in-consts-not-sync.rs:11:1
64+
|
65+
LL | const D: LazyCell<i32> = LazyCell::new(|| 0);
66+
| ^^^^^^^^^-------------^^^^^^^^^^^^^^^^^^^^^^^
67+
| |
68+
| `LazyCell` is an interior mutable type
69+
|
70+
= note: each usage of a `const` item creates a new temporary
71+
= note: only the temporaries and never the original `const` item `D` will be modified
72+
= help: for use as an initializer, consider using an inline-const `const { /* ... */ }` at the usage site instead
73+
help: for a shared instance of `D`, consider using a `static` item instead
74+
|
75+
LL | static D: LazyCell<i32> = LazyCell::new(|| 0);
76+
| ~~~~~~
77+
help: alternatively consider allowing the lint
78+
|
79+
LL | #[allow(interior_mutable_consts)] const D: LazyCell<i32> = LazyCell::new(|| 0);
80+
| +++++++++++++++++++++++++++++++++
81+
82+
warning: interior mutability in `const` item have no effect to the `const` item it-self
83+
--> $DIR/interior-mutable-types-in-consts-not-sync.rs:13:1
84+
|
85+
LL | const E: OnceCell<i32> = OnceCell::new();
86+
| ^^^^^^^^^-------------^^^^^^^^^^^^^^^^^^^
87+
| |
88+
| `OnceCell` is an interior mutable type
89+
|
90+
= note: each usage of a `const` item creates a new temporary
91+
= note: only the temporaries and never the original `const` item `E` will be modified
92+
= help: for use as an initializer, consider using an inline-const `const { /* ... */ }` at the usage site instead
93+
help: for a shared instance of `E`, consider using a `static` item instead
94+
|
95+
LL | static E: OnceCell<i32> = OnceCell::new();
96+
| ~~~~~~
97+
help: alternatively consider allowing the lint
98+
|
99+
LL | #[allow(interior_mutable_consts)] const E: OnceCell<i32> = OnceCell::new();
100+
| +++++++++++++++++++++++++++++++++
101+
102+
warning: 5 warnings emitted
103+

‎tests/ui/lint/interior-mutable-types-in-consts.fixed‎

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
//@ check-pass
2+
//@ run-rustfix
3+
4+
#![allow(dead_code)] // for rustfix
5+
#![feature(reentrant_lock)]
6+
7+
use std::sync::{Once, Barrier, Condvar, LazyLock, Mutex, OnceLock, ReentrantLock, RwLock};
8+
use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicI32, AtomicU32};
9+
10+
#[allow(interior_mutable_consts)] static A: Once = Once::new();
11+
//~^ WARN interior mutability in `const` item
12+
#[allow(interior_mutable_consts)] static B: Barrier = Barrier::new(0);
13+
//~^ WARN interior mutability in `const` item
14+
#[allow(interior_mutable_consts)] static C: Condvar = Condvar::new();
15+
//~^ WARN interior mutability in `const` item
16+
#[allow(interior_mutable_consts)] static D: LazyLock<i32> = LazyLock::new(|| 0);
17+
//~^ WARN interior mutability in `const` item
18+
#[allow(interior_mutable_consts)] static E: Mutex<i32> = Mutex::new(0);
19+
//~^ WARN interior mutability in `const` item
20+
#[allow(interior_mutable_consts)] static F: OnceLock<i32> = OnceLock::new();
21+
//~^ WARN interior mutability in `const` item
22+
#[allow(interior_mutable_consts)] static G: ReentrantLock<i32> = ReentrantLock::new(0);
23+
//~^ WARN interior mutability in `const` item
24+
#[allow(interior_mutable_consts)] static H: RwLock<i32> = RwLock::new(0);
25+
//~^ WARN interior mutability in `const` item
26+
#[allow(interior_mutable_consts)] static I: AtomicBool = AtomicBool::new(false);
27+
//~^ WARN interior mutability in `const` item
28+
#[allow(interior_mutable_consts)] static J: AtomicPtr<i32> = AtomicPtr::new(std::ptr::null_mut());
29+
//~^ WARN interior mutability in `const` item
30+
#[allow(interior_mutable_consts)] static K: AtomicI32 = AtomicI32::new(0);
31+
//~^ WARN interior mutability in `const` item
32+
#[allow(interior_mutable_consts)] static L: AtomicU32 = AtomicU32::new(0);
33+
//~^ WARN interior mutability in `const` item
34+
35+
#[allow(interior_mutable_consts)] pub(crate) static X: Once = Once::new();
36+
//~^ WARN interior mutability in `const` item
37+
38+
fn main() {
39+
#[allow(interior_mutable_consts)] static Z: Once = Once::new();
40+
//~^ WARN interior mutability in `const` item
41+
}
42+
43+
struct S;
44+
impl S {
45+
const Z: Once = Once::new(); // not a const-item
46+
}

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

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
//@ check-pass
2+
//@ run-rustfix
3+
4+
#![allow(dead_code)] // for rustfix
5+
#![feature(reentrant_lock)]
6+
7+
use std::sync::{Once, Barrier, Condvar, LazyLock, Mutex, OnceLock, ReentrantLock, RwLock};
8+
use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicI32, AtomicU32};
9+
10+
const A: Once = Once::new();
11+
//~^ WARN interior mutability in `const` item
12+
const B: Barrier = Barrier::new(0);
13+
//~^ WARN interior mutability in `const` item
14+
const C: Condvar = Condvar::new();
15+
//~^ WARN interior mutability in `const` item
16+
const D: LazyLock<i32> = LazyLock::new(|| 0);
17+
//~^ WARN interior mutability in `const` item
18+
const E: Mutex<i32> = Mutex::new(0);
19+
//~^ WARN interior mutability in `const` item
20+
const F: OnceLock<i32> = OnceLock::new();
21+
//~^ WARN interior mutability in `const` item
22+
const G: ReentrantLock<i32> = ReentrantLock::new(0);
23+
//~^ WARN interior mutability in `const` item
24+
const H: RwLock<i32> = RwLock::new(0);
25+
//~^ WARN interior mutability in `const` item
26+
const I: AtomicBool = AtomicBool::new(false);
27+
//~^ WARN interior mutability in `const` item
28+
const J: AtomicPtr<i32> = AtomicPtr::new(std::ptr::null_mut());
29+
//~^ WARN interior mutability in `const` item
30+
const K: AtomicI32 = AtomicI32::new(0);
31+
//~^ WARN interior mutability in `const` item
32+
const L: AtomicU32 = AtomicU32::new(0);
33+
//~^ WARN interior mutability in `const` item
34+
35+
pub(crate) const X: Once = Once::new();
36+
//~^ WARN interior mutability in `const` item
37+
38+
fn main() {
39+
const Z: Once = Once::new();
40+
//~^ WARN interior mutability in `const` item
41+
}
42+
43+
struct S;
44+
impl S {
45+
const Z: Once = Once::new(); // not a const-item
46+
}

0 commit comments

Comments
 (0)