clippy_utils/
msrvs.rs

1use crate::sym;
2use rustc_ast::Attribute;
3use rustc_ast::attr::AttributeExt;
4use rustc_attr_parsing::parse_version;
5use rustc_data_structures::smallvec::SmallVec;
6use rustc_hir::def_id::DefId;
7use rustc_hir::{HirId, RustcVersion, StabilityLevel, StableSince};
8use rustc_lint::LateContext;
9use rustc_middle::ty::TyCtxt;
10use rustc_session::Session;
11use rustc_span::Symbol;
12use serde::Deserialize;
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
26// names may refer to stabilized feature flags or library items
27msrv_aliases! {
28    1,97,0 { ISOLATE_LOWEST_ONE, BIT_WIDTH }
29    1,93,0 { VEC_DEQUE_POP_BACK_IF, VEC_DEQUE_POP_FRONT_IF }
30    1,91,0 { DURATION_FROM_MINUTES_HOURS }
31    1,88,0 { LET_CHAINS, AS_CHUNKS }
32    1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT, CONST_CHAR_IS_DIGIT, UNSIGNED_IS_MULTIPLE_OF, INTEGER_SIGN_CAST }
33    1,86,0 { VEC_POP_IF }
34    1,85,0 { UINT_FLOAT_MIDPOINT, CONST_SIZE_OF_VAL, WAKER_NOOP }
35    1,84,0 { CONST_OPTION_AS_SLICE, MANUAL_DANGLING_PTR }
36    1,83,0 { CONST_EXTERN_FN, CONST_FLOAT_BITS_CONV, CONST_FLOAT_CLASSIFY, CONST_MUT_REFS, CONST_UNWRAP }
37    1,82,0 { IS_NONE_OR, REPEAT_N, RAW_REF_OP, SPECIALIZED_TO_STRING_FOR_REFS }
38    1,81,0 { LINT_REASONS_STABILIZATION, ERROR_IN_CORE, EXPLICIT_SELF_TYPE_ELISION, DURATION_ABS_DIFF }
39    1,80,0 { BOX_INTO_ITER, LAZY_CELL }
40    1,79,0 { CONST_BLOCKS, CSTR_COUNT_BYTES }
41    1,77,0 { C_STR_LITERALS }
42    1,76,0 { PTR_FROM_REF, OPTION_RESULT_INSPECT }
43    1,75,0 { OPTION_AS_SLICE }
44    1,74,0 { REPR_RUST, IO_ERROR_OTHER }
45    1,73,0 { DIV_CEIL }
46    1,71,0 { TUPLE_ARRAY_CONVERSIONS, BUILD_HASHER_HASH_ONE }
47    1,70,0 { OPTION_RESULT_IS_VARIANT_AND, BINARY_HEAP_RETAIN }
48    1,68,0 { PATH_MAIN_SEPARATOR_STR }
49    1,67,0 { ILOG2 }
50    1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
51    1,63,0 { CLONE_INTO, CONST_SLICE_FROM_REF }
52    1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE, CONST_EXTERN_C_FN }
53    1,61,0 { CONST_FN_TRAIT_BOUND }
54    1,60,0 { ABS_DIFF }
55    1,59,0 { THREAD_LOCAL_CONST_INIT }
56    1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY, CONST_RAW_PTR_DEREF }
57    1,57,0 { MAP_WHILE, CONST_PANIC }
58    1,56,0 { CONST_FN_UNION }
59    1,55,0 { SEEK_REWIND }
60    1,54,0 { INTO_KEYS }
61    1,53,0 { OR_PATTERNS, INTEGER_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
62    1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
63    1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
64    1,50,0 { BOOL_THEN, CLAMP, SLICE_FILL }
65    1,47,0 { TAU, IS_ASCII_DIGIT_CONST, ARRAY_IMPL_ANY_LEN, SATURATING_SUB_CONST }
66    1,46,0 { CONST_IF_MATCH, OPTION_ZIP }
67    1,45,0 { STR_STRIP_PREFIX }
68    1,43,0 { LOG2_10, LOG10_2, NUMERIC_ASSOCIATED_CONSTANTS }
69    1,42,0 { MATCHES_MACRO, SLICE_PATTERNS, PTR_SLICE_RAW_PARTS }
70    1,41,0 { RE_REBALANCING_COHERENCE, RESULT_MAP_OR, RESULT_MAP_OR_ELSE }
71    1,40,0 { MEM_TAKE, NON_EXHAUSTIVE, OPTION_AS_DEREF }
72    1,38,0 { POINTER_CAST, REM_EUCLID }
73    1,37,0 { TYPE_ALIAS_ENUM_VARIANTS }
74    1,36,0 { ITERATOR_COPIED }
75    1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
76    1,34,0 { TRY_FROM }
77    1,33,0 { UNDERSCORE_IMPORTS }
78    1,32,0 { CONST_IS_POWER_OF_TWO, CONST_DURATION_FROM_NANOS_MICROS_MILLIS_SECS }
79    1,31,0 { OPTION_REPLACE }
80    1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
81    1,29,0 { ITER_FLATTEN }
82    1,28,0 { FROM_BOOL, REPEAT_WITH, SLICE_FROM_REF }
83    1,27,0 { ITERATOR_TRY_FOLD, DOUBLE_ENDED_ITERATOR_RFIND, DURATION_FROM_NANOS_MICROS }
84    1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN, POINTER_ADD_SUB_METHODS }
85    1,24,0 { IS_ASCII_DIGIT, PTR_NULL }
86    1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
87    1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
88    1,16,0 { STR_REPEAT, RESULT_UNWRAP_OR_DEFAULT }
89    1,15,0 { MAYBE_BOUND_IN_WHERE }
90    1,13,0 { QUESTION_MARK_OPERATOR }
91    1,3,0 { DURATION_FROM_MILLIS_SECS }
92}
93
94/// `#[clippy::msrv]` attributes are rarely used outside of Clippy's test suite, as a basic
95/// optimization we can skip traversing the HIR in [`Msrv::meets`] if we never saw an MSRV attribute
96/// during the early lint passes
97static SEEN_MSRV_ATTR: AtomicBool = AtomicBool::new(false);
98
99/// Tracks the current MSRV from `clippy.toml`, `Cargo.toml` or set via `#[clippy::msrv]` in late
100/// lint passes, use [`MsrvStack`] for early passes
101#[derive(Copy, Clone, Debug, Default)]
102pub struct Msrv(Option<RustcVersion>);
103
104impl<'de> Deserialize<'de> for Msrv {
105    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
106    where
107        D: serde::Deserializer<'de>,
108    {
109        let v = String::deserialize(deserializer)?;
110        parse_version(Symbol::intern(&v))
111            .map(|v| Self(Some(v)))
112            .ok_or_else(|| serde::de::Error::custom("not a valid Rust version"))
113    }
114}
115
116impl Msrv {
117    /// Returns the MSRV at the current node
118    ///
119    /// If the crate being linted uses an `#[clippy::msrv]` attribute this will search the parent
120    /// nodes for that attribute, prefer to run this check after cheaper pattern matching operations
121    pub fn current(self, cx: &LateContext<'_>) -> Option<RustcVersion> {
122        if SEEN_MSRV_ATTR.load(Ordering::Relaxed) {
123            self.for_attrs(cx.tcx, cx.last_node_with_lint_attrs)
124        } else {
125            self.0
126        }
127    }
128
129    /// Returns the MSRV at the specified node
130    ///
131    /// If the crate being linted uses an `#[clippy::msrv]` attribute this will search the parent
132    /// nodes for that attribute, prefer to run this check after cheaper pattern matching operations
133    pub fn at(self, tcx: TyCtxt<'_>, node: HirId) -> Option<RustcVersion> {
134        if SEEN_MSRV_ATTR.load(Ordering::Relaxed) {
135            self.for_attrs(tcx, node)
136        } else {
137            self.0
138        }
139    }
140
141    fn for_attrs(self, tcx: TyCtxt<'_>, node: HirId) -> Option<RustcVersion> {
142        once(node)
143            .chain(tcx.hir_parent_id_iter(node))
144            .find_map(|id| parse_attrs(tcx.sess, tcx.hir_attrs(id)))
145            .or(self.0)
146    }
147
148    /// Checks if a required version from [this module](self) is met at the current node
149    ///
150    /// If the crate being linted uses an `#[clippy::msrv]` attribute this will search the parent
151    /// nodes for that attribute, prefer to run this check after cheaper pattern matching operations
152    pub fn meets(self, cx: &LateContext<'_>, required: RustcVersion) -> bool {
153        self.current(cx).is_none_or(|msrv| msrv >= required)
154    }
155
156    /// Checks if a required version from [this module](self) is met at the specified node
157    ///
158    /// If the crate being linted uses an `#[clippy::msrv]` attribute this will search the parent
159    /// nodes for that attribute, prefer to run this check after cheaper pattern matching operations
160    pub fn meets_at(self, tcx: TyCtxt<'_>, node: HirId, required: RustcVersion) -> bool {
161        self.at(tcx, node).is_none_or(|msrv| msrv >= required)
162    }
163
164    pub fn read_cargo(&mut self, sess: &Session) {
165        let cargo_msrv = std::env::var("CARGO_PKG_RUST_VERSION")
166            .ok()
167            .and_then(|v| parse_version(Symbol::intern(&v)));
168
169        match (self.0, cargo_msrv) {
170            (None, Some(cargo_msrv)) => self.0 = Some(cargo_msrv),
171            (Some(clippy_msrv), Some(cargo_msrv)) if clippy_msrv != cargo_msrv => {
172                sess.dcx().warn(format!(
173                    "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{clippy_msrv}` from `clippy.toml`"
174                ));
175            },
176            _ => {},
177        }
178    }
179
180    pub fn is_stable(self, cx: &LateContext<'_>, def_id: DefId) -> bool {
181        cx.tcx.lookup_stability(def_id).is_none_or(|stability| {
182            if let StabilityLevel::Stable { since, .. } = stability.level {
183                let version = match since {
184                    StableSince::Version(version) => version,
185                    StableSince::Current => RustcVersion::CURRENT,
186                    StableSince::Err(_) => return false,
187                };
188
189                self.meets(cx, version)
190            } else {
191                // Unstable fn.
192                // FIXME: can we check that the feature is enabled?
193                // Please see https://github.com/rust-lang/rust-clippy/pull/17309#discussion_r3486693263 for false-positive concerns.
194                false
195            }
196        })
197    }
198}
199
200/// Tracks the current MSRV from `clippy.toml`, `Cargo.toml` or set via `#[clippy::msrv]` in early
201/// lint passes, use [`Msrv`] for late passes
202#[derive(Debug, Clone)]
203pub struct MsrvStack {
204    stack: SmallVec<[RustcVersion; 2]>,
205}
206
207impl MsrvStack {
208    pub fn new(initial: Msrv) -> Self {
209        Self {
210            stack: SmallVec::from_iter(initial.0),
211        }
212    }
213
214    pub fn current(&self) -> Option<RustcVersion> {
215        self.stack.last().copied()
216    }
217
218    pub fn meets(&self, required: RustcVersion) -> bool {
219        self.current().is_none_or(|msrv| msrv >= required)
220    }
221
222    pub fn check_attributes(&mut self, sess: &Session, attrs: &[Attribute]) {
223        if let Some(version) = parse_attrs(sess, attrs) {
224            SEEN_MSRV_ATTR.store(true, Ordering::Relaxed);
225            self.stack.push(version);
226        }
227    }
228
229    pub fn check_attributes_post(&mut self, sess: &Session, attrs: &[Attribute]) {
230        if parse_attrs(sess, attrs).is_some() {
231            self.stack.pop();
232        }
233    }
234}
235
236fn parse_attrs(sess: &Session, attrs: &[impl AttributeExt]) -> Option<RustcVersion> {
237    let mut msrv_attrs = attrs.iter().filter(|attr| attr.path_matches(&[sym::clippy, sym::msrv]));
238
239    let msrv_attr = msrv_attrs.next()?;
240
241    if let Some(duplicate) = msrv_attrs.next_back() {
242        sess.dcx()
243            .struct_span_err(duplicate.span(), "`clippy::msrv` is defined multiple times")
244            .with_span_note(msrv_attr.span(), "first definition found here")
245            .emit();
246    }
247
248    let Some(msrv) = msrv_attr.value_str() else {
249        sess.dcx().span_err(msrv_attr.span(), "bad clippy attribute");
250        return None;
251    };
252
253    let Some(version) = parse_version(msrv) else {
254        sess.dcx()
255            .span_err(msrv_attr.span(), format!("`{msrv}` is not a valid Rust version"));
256        return None;
257    };
258
259    Some(version)
260}
clippy_utils/msrvs.rs

clippy_utils/
msrvs.rs
