1use crate::{is_in_const_context, sym};
2use rustc_ast::Attribute;
3use rustc_ast::attr::AttributeExt;
4use rustc_attr_ir::RustcVersion;
5use rustc_attr_parsing::parse_version;
6use rustc_data_structures::smallvec::SmallVec;
7use rustc_hir::def::DefKind;
8use rustc_hir::def_id::DefId;
9use rustc_hir::{Constness, HirId, StabilityLevel, StableSince};
10use rustc_lint::LateContext;
11use rustc_middle::ty::TyCtxt;
12use rustc_session::Session;
13use std::iter::once;
14use std::sync::atomic::{AtomicBool, Ordering};
15
16macro_rules! msrv_aliases {
17 ($($major:literal,$minor:literal,$patch:literal {
18 $($name:ident),* $(,)?
19 })*) => {
20 $($(
21 pub const $name: RustcVersion = RustcVersion { major: $major, minor :$minor, patch: $patch };
22 )*)*
23 };
24}
25
26msrv_aliases! {
28 1,99,0 { BOX_INTO_NON_NULL }
29 1,98,0 { MAP_OR_DEFAULT }
30 1,97,0 { ISOLATE_LOWEST_ONE, BIT_WIDTH }
31 1,94,0 { EULER_GAMMA, GOLDEN_RATIO, MUL_ADD_CONST }
32 1,93,0 { VEC_DEQUE_POP_BACK_IF, VEC_DEQUE_POP_FRONT_IF }
33 1,91,0 { DURATION_FROM_MINUTES_HOURS }
34 1,89,0 { NONNULL_FROM_MUT }
35 1,88,0 { LET_CHAINS, AS_CHUNKS, RAW_PTR_DEFAULT }
36 1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT, CONST_CHAR_IS_DIGIT, UNSIGNED_IS_MULTIPLE_OF, INTEGER_SIGN_CAST }
37 1,86,0 { VEC_POP_IF }
38 1,85,0 { UINT_FLOAT_MIDPOINT, CONST_SIZE_OF_VAL, WAKER_NOOP, ABS_CONST, RADIANS_CONST, CONST_MEM_SWAP }
39 1,84,0 { CONST_OPTION_AS_SLICE, MANUAL_DANGLING_PTR }
40 1,83,0 { CONST_EXTERN_FN, CONST_FLOAT_BITS_CONV, CONST_FLOAT_CLASSIFY, CONST_MUT_REFS, CONST_UNWRAP }
41 1,82,0 { IS_NONE_OR, REPEAT_N, RAW_REF_OP, SPECIALIZED_TO_STRING_FOR_REFS }
42 1,81,0 { LINT_REASONS_STABILIZATION, ERROR_IN_CORE, EXPLICIT_SELF_TYPE_ELISION, DURATION_ABS_DIFF }
43 1,80,0 { BOX_INTO_ITER, LAZY_CELL }
44 1,79,0 { CONST_BLOCKS, CSTR_COUNT_BYTES }
45 1,77,0 { C_STR_LITERALS }
46 1,76,0 { PTR_FROM_REF, OPTION_RESULT_INSPECT }
47 1,75,0 { OPTION_AS_SLICE }
48 1,74,0 { REPR_RUST, IO_ERROR_OTHER }
49 1,73,0 { DIV_CEIL }
50 1,71,0 { TUPLE_ARRAY_CONVERSIONS, BUILD_HASHER_HASH_ONE }
51 1,70,0 { OPTION_RESULT_IS_VARIANT_AND, BINARY_HEAP_RETAIN }
52 1,68,0 { PATH_MAIN_SEPARATOR_STR }
53 1,67,0 { ILOG2 }
54 1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
55 1,63,0 { CLONE_INTO, CONST_SLICE_FROM_REF }
56 1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE, CONST_EXTERN_C_FN }
57 1,61,0 { CONST_FN_TRAIT_BOUND }
58 1,60,0 { ABS_DIFF }
59 1,59,0 { THREAD_LOCAL_CONST_INIT }
60 1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY, CONST_RAW_PTR_DEREF }
61 1,57,0 { MAP_WHILE, CONST_PANIC }
62 1,56,0 { CONST_FN_UNION }
63 1,55,0 { SEEK_REWIND }
64 1,54,0 { INTO_KEYS }
65 1,53,0 { OR_PATTERNS, INTEGER_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
66 1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
67 1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
68 1,50,0 { BOOL_THEN, CLAMP, SLICE_FILL }
69 1,47,0 { TAU, IS_ASCII_DIGIT_CONST, ARRAY_IMPL_ANY_LEN, SATURATING_SUB_CONST }
70 1,46,0 { CONST_IF_MATCH, OPTION_ZIP }
71 1,45,0 { STR_STRIP_PREFIX }
72 1,43,0 { LOG2_10, LOG10_2, NUMERIC_ASSOCIATED_CONSTANTS }
73 1,42,0 { MATCHES_MACRO, SLICE_PATTERNS, PTR_SLICE_RAW_PARTS }
74 1,41,0 { RE_REBALANCING_COHERENCE, RESULT_MAP_OR, RESULT_MAP_OR_ELSE }
75 1,40,0 { MEM_TAKE, NON_EXHAUSTIVE, OPTION_AS_DEREF }
76 1,38,0 { POINTER_CAST, REM_EUCLID }
77 1,37,0 { TYPE_ALIAS_ENUM_VARIANTS }
78 1,36,0 { ITERATOR_COPIED }
79 1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
80 1,34,0 { TRY_FROM }
81 1,33,0 { UNDERSCORE_IMPORTS }
82 1,32,0 { CONST_IS_POWER_OF_TWO, CONST_DURATION_FROM_NANOS_MICROS_MILLIS_SECS }
83 1,31,0 { OPTION_REPLACE }
84 1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
85 1,29,0 { ITER_FLATTEN }
86 1,28,0 { FROM_BOOL, REPEAT_WITH, SLICE_FROM_REF }
87 1,27,0 { ITERATOR_TRY_FOLD, DOUBLE_ENDED_ITERATOR_RFIND, DURATION_FROM_NANOS_MICROS }
88 1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN, POINTER_ADD_SUB_METHODS, BOX_LEAK }
89 1,24,0 { IS_ASCII_DIGIT, PTR_NULL }
90 1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
91 1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
92 1,16,0 { STR_REPEAT, RESULT_UNWRAP_OR_DEFAULT }
93 1,15,0 { MAYBE_BOUND_IN_WHERE }
94 1,13,0 { QUESTION_MARK_OPERATOR }
95 1,3,0 { DURATION_FROM_MILLIS_SECS }
96}
97
98static SEEN_MSRV_ATTR: AtomicBool = AtomicBool::new(false);
102
103#[derive(Copy, Clone, Debug, Default)]
106pub struct Msrv(Option<RustcVersion>);
107
108impl From<Option<RustcVersion>> for Msrv {
109 #[inline]
110 fn from(value: Option<RustcVersion>) -> Self {
111 Self(value)
112 }
113}
114
115impl Msrv {
116 pub fn current(self, cx: &LateContext<'_>) -> Option<RustcVersion> {
121 if SEEN_MSRV_ATTR.load(Ordering::Relaxed) {
122 self.for_attrs(cx.tcx, cx.last_node_with_lint_attrs)
123 } else {
124 self.0
125 }
126 }
127
128 pub fn at(self, tcx: TyCtxt<'_>, node: HirId) -> Option<RustcVersion> {
133 if SEEN_MSRV_ATTR.load(Ordering::Relaxed) {
134 self.for_attrs(tcx, node)
135 } else {
136 self.0
137 }
138 }
139
140 fn for_attrs(self, tcx: TyCtxt<'_>, node: HirId) -> Option<RustcVersion> {
141 once(node)
142 .chain(tcx.hir_parent_id_iter(node))
143 .find_map(|id| parse_attrs(tcx.hir_attrs(id)))
144 .or(self.0)
145 }
146
147 pub fn meets(self, cx: &LateContext<'_>, required: RustcVersion) -> bool {
152 self.current(cx).is_none_or(|msrv| msrv >= required)
153 }
154 pub fn meets_at(self, tcx: TyCtxt<'_>, node: HirId, required: RustcVersion) -> bool {
159 self.at(tcx, node).is_none_or(|msrv| msrv >= required)
160 }
161
162 pub fn is_stable(self, cx: &LateContext<'_>, def_id: DefId) -> bool {
163 self.stability_met(cx, cx.tcx.lookup_stability(def_id).map(|stability| stability.level))
164 }
165
166 pub fn is_const_stable(self, cx: &LateContext<'_>, def_id: DefId) -> bool {
174 let constness = match cx.tcx.def_kind(def_id) {
175 DefKind::Impl { of_trait: true } => cx.tcx.impl_trait_header(def_id).constness,
178 _ => cx.tcx.constness(def_id),
179 };
180
181 matches!(constness, Constness::Const { .. })
182 && self.stability_met(
183 cx,
184 cx.tcx.lookup_const_stability(def_id).map(|stability| stability.level),
185 )
186 }
187
188 pub fn is_stable_or_const_stable(self, cx: &LateContext<'_>, def_id: DefId) -> bool {
193 if is_in_const_context(cx) {
194 self.is_const_stable(cx, def_id)
195 } else {
196 self.is_stable(cx, def_id)
197 }
198 }
199
200 fn stability_met(self, cx: &LateContext<'_>, level: Option<StabilityLevel>) -> bool {
201 level.is_none_or(|level| {
202 if let StabilityLevel::Stable { since, .. } = level {
203 let version = match since {
204 StableSince::Version(version) => version,
205 StableSince::Current => RustcVersion::CURRENT,
206 StableSince::Err(_) => return false,
207 };
208
209 self.meets(cx, version)
210 } else {
211 false
215 }
216 })
217 }
218}
219
220#[derive(Debug, Clone)]
223pub struct MsrvStack {
224 stack: SmallVec<[RustcVersion; 2]>,
225}
226
227impl From<Option<RustcVersion>> for MsrvStack {
228 #[inline]
229 fn from(value: Option<RustcVersion>) -> Self {
230 Self {
231 stack: SmallVec::from_iter(value),
232 }
233 }
234}
235
236impl MsrvStack {
237 pub fn current(&self) -> Option<RustcVersion> {
238 self.stack.last().copied()
239 }
240
241 pub fn meets(&self, required: RustcVersion) -> bool {
242 self.current().is_none_or(|msrv| msrv >= required)
243 }
244
245 pub fn check_attributes(&mut self, attrs: &[Attribute]) {
246 if let Some(version) = parse_attrs(attrs) {
247 SEEN_MSRV_ATTR.store(true, Ordering::Relaxed);
248 self.stack.push(version);
249 }
250 }
251
252 pub fn check_attributes_post(&mut self, attrs: &[Attribute]) {
253 if parse_attrs(attrs).is_some() {
254 self.stack.pop();
255 }
256 }
257}
258
259fn parse_attrs(attrs: &[impl AttributeExt]) -> Option<RustcVersion> {
260 let msrv_attr = attrs.iter().find(|attr| attr.path_matches(&[sym::clippy, sym::msrv]))?;
261
262 let msrv = msrv_attr.value_str()?;
263
264 parse_version(msrv)
265}
266
267pub fn check_attrs(sess: &Session, attrs: &[impl AttributeExt]) {
268 let mut msrv_attrs = attrs.iter().filter(|attr| attr.path_matches(&[sym::clippy, sym::msrv]));
269
270 let Some(msrv_attr) = msrv_attrs.next() else {
271 return;
272 };
273
274 if let Some(duplicate) = msrv_attrs.next_back() {
275 sess.dcx()
276 .struct_span_err(duplicate.span(), "`clippy::msrv` is defined multiple times")
277 .with_span_note(msrv_attr.span(), "first definition found here")
278 .emit();
279 }
280
281 let Some(msrv) = msrv_attr.value_str() else {
282 sess.dcx().span_err(msrv_attr.span(), "bad clippy attribute");
283 return;
284 };
285
286 if parse_version(msrv).is_none() {
287 sess.dcx()
288 .span_err(msrv_attr.span(), format!("`{msrv}` is not a valid Rust version"));
289 }
290}