1 use rustc_ast::LitKind::{Byte, Char};
2 use rustc_errors::Applicability;
3 use rustc_hir::{Expr, ExprKind, PatKind, RangeEnd};
4 use rustc_lint::{LateContext, LateLintPass};
5 use rustc_semver::RustcVersion;
6 use rustc_session::{declare_tool_lint, impl_lint_pass};
7 use rustc_span::{def_id::DefId, sym};
10 diagnostics::span_lint_and_sugg, in_constant, macros::root_macro_call, meets_msrv, msrvs, source::snippet,
13 declare_clippy_lint! {
15 /// Suggests to use dedicated built-in methods,
16 /// `is_ascii_(lowercase|uppercase|digit)` for checking on corresponding ascii range
18 /// ### Why is this bad?
19 /// Using the built-in functions is more readable and makes it
20 /// clear that it's not a specific subset of characters, but all
21 /// ASCII (lowercase|uppercase|digit) characters.
25 /// assert!(matches!('x', 'a'..='z'));
26 /// assert!(matches!(b'X', b'A'..=b'Z'));
27 /// assert!(matches!('2', '0'..='9'));
28 /// assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
34 /// assert!('x'.is_ascii_lowercase());
35 /// assert!(b'X'.is_ascii_uppercase());
36 /// assert!('2'.is_ascii_digit());
37 /// assert!('x'.is_ascii_alphabetic());
40 #[clippy::version = "1.66.0"]
41 pub MANUAL_IS_ASCII_CHECK,
43 "use dedicated method to check ascii range"
45 impl_lint_pass!(ManualIsAsciiCheck => [MANUAL_IS_ASCII_CHECK]);
47 pub struct ManualIsAsciiCheck {
48 msrv: Option<RustcVersion>,
51 impl ManualIsAsciiCheck {
53 pub fn new(msrv: Option<RustcVersion>) -> Self {
58 #[derive(Debug, PartialEq)]
60 /// 'a'..='z' | b'a'..=b'z'
62 /// 'A'..='Z' | b'A'..=b'Z'
64 /// AsciiLower | AsciiUpper
71 impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
72 fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
73 if !meets_msrv(self.msrv, msrvs::IS_ASCII_DIGIT) {
77 if in_constant(cx, expr.hir_id) && !meets_msrv(self.msrv, msrvs::IS_ASCII_DIGIT_CONST) {
81 let Some(macro_call) = root_macro_call(expr.span) else { return };
83 if is_matches_macro(cx, macro_call.def_id) {
84 if let ExprKind::Match(recv, [arm, ..], _) = expr.kind {
85 let range = check_pat(&arm.pat.kind);
87 if let Some(sugg) = match range {
88 CharRange::UpperChar => Some("is_ascii_uppercase"),
89 CharRange::LowerChar => Some("is_ascii_lowercase"),
90 CharRange::FullChar => Some("is_ascii_alphabetic"),
91 CharRange::Digit => Some("is_ascii_digit"),
92 CharRange::Otherwise => None,
94 let default_snip = "..";
95 // `snippet_with_applicability` may set applicability to `MaybeIncorrect` for
96 // macro span, so we check applicability manually by comparing `recv` is not default.
97 let recv = snippet(cx, recv.span, default_snip);
99 let applicability = if recv == default_snip {
100 Applicability::HasPlaceholders
102 Applicability::MachineApplicable
107 MANUAL_IS_ASCII_CHECK,
109 "manual check for common ascii range",
111 format!("{recv}.{sugg}()"),
119 extract_msrv_attr!(LateContext);
122 fn check_pat(pat_kind: &PatKind<'_>) -> CharRange {
124 PatKind::Or(pats) => {
125 let ranges = pats.iter().map(|p| check_pat(&p.kind)).collect::<Vec<_>>();
127 if ranges.len() == 2 && ranges.contains(&CharRange::UpperChar) && ranges.contains(&CharRange::LowerChar) {
133 PatKind::Range(Some(start), Some(end), kind) if *kind == RangeEnd::Included => check_range(start, end),
134 _ => CharRange::Otherwise,
138 fn check_range(start: &Expr<'_>, end: &Expr<'_>) -> CharRange {
139 if let ExprKind::Lit(start_lit) = &start.kind
140 && let ExprKind::Lit(end_lit) = &end.kind {
141 match (&start_lit.node, &end_lit.node) {
142 (Char('a'), Char('z')) | (Byte(b'a'), Byte(b'z')) => CharRange::LowerChar,
143 (Char('A'), Char('Z')) | (Byte(b'A'), Byte(b'Z')) => CharRange::UpperChar,
144 (Char('0'), Char('9')) | (Byte(b'0'), Byte(b'9')) => CharRange::Digit,
145 _ => CharRange::Otherwise,
152 fn is_matches_macro(cx: &LateContext<'_>, macro_def_id: DefId) -> bool {
153 if let Some(name) = cx.tcx.get_diagnostic_name(macro_def_id) {
154 return sym::matches_macro == name;