src/tools/clippy/clippy_lints/src/almost_complete_letter_range.rs

   1 use clippy_utils::diagnostics::span_lint_and_then;
   2 use clippy_utils::source::{trim_span, walk_span_to_context};
   3 use clippy_utils::{meets_msrv, msrvs};
   4 use rustc_ast::ast::{Expr, ExprKind, LitKind, Pat, PatKind, RangeEnd, RangeLimits};
   5 use rustc_errors::Applicability;
   6 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
   7 use rustc_middle::lint::in_external_macro;
   8 use rustc_semver::RustcVersion;
   9 use rustc_session::{declare_tool_lint, impl_lint_pass};
  10 use rustc_span::Span;
  11
  12 declare_clippy_lint! {
  13     /// ### What it does
  14     /// Checks for ranges which almost include the entire range of letters from 'a' to 'z', but
  15     /// don't because they're a half open range.
  16     ///
  17     /// ### Why is this bad?
  18     /// This (`'a'..'z'`) is almost certainly a typo meant to include all letters.
  19     ///
  20     /// ### Example
  21     /// ```rust
  22     /// let _ = 'a'..'z';
  23     /// ```
  24     /// Use instead:
  25     /// ```rust
  26     /// let _ = 'a'..='z';
  27     /// ```
  28     #[clippy::version = "1.63.0"]
  29     pub ALMOST_COMPLETE_LETTER_RANGE,
  30     suspicious,
  31     "almost complete letter range"
  32 }
  33 impl_lint_pass!(AlmostCompleteLetterRange => [ALMOST_COMPLETE_LETTER_RANGE]);
  34
  35 pub struct AlmostCompleteLetterRange {
  36     msrv: Option<RustcVersion>,
  37 }
  38 impl AlmostCompleteLetterRange {
  39     pub fn new(msrv: Option<RustcVersion>) -> Self {
  40         Self { msrv }
  41     }
  42 }
  43 impl EarlyLintPass for AlmostCompleteLetterRange {
  44     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
  45         if let ExprKind::Range(Some(start), Some(end), RangeLimits::HalfOpen) = &e.kind {
  46             let ctxt = e.span.ctxt();
  47             let sugg = if let Some(start) = walk_span_to_context(start.span, ctxt)
  48                 && let Some(end) = walk_span_to_context(end.span, ctxt)
  49                 && meets_msrv(self.msrv, msrvs::RANGE_INCLUSIVE)
  50             {
  51                 Some((trim_span(cx.sess().source_map(), start.between(end)), "..="))
  52             } else {
  53                 None
  54             };
  55             check_range(cx, e.span, start, end, sugg);
  56         }
  57     }
  58
  59     fn check_pat(&mut self, cx: &EarlyContext<'_>, p: &Pat) {
  60         if let PatKind::Range(Some(start), Some(end), kind) = &p.kind
  61             && matches!(kind.node, RangeEnd::Excluded)
  62         {
  63             let sugg = if meets_msrv(self.msrv, msrvs::RANGE_INCLUSIVE) {
  64                 "..="
  65             } else {
  66                 "..."
  67             };
  68             check_range(cx, p.span, start, end, Some((kind.span, sugg)));
  69         }
  70     }
  71
  72     extract_msrv_attr!(EarlyContext);
  73 }
  74
  75 fn check_range(cx: &EarlyContext<'_>, span: Span, start: &Expr, end: &Expr, sugg: Option<(Span, &str)>) {
  76     if let ExprKind::Lit(start_lit) = &start.peel_parens().kind
  77         && let ExprKind::Lit(end_lit) = &end.peel_parens().kind
  78         && matches!(
  79             (&start_lit.kind, &end_lit.kind),
  80             (LitKind::Byte(b'a') | LitKind::Char('a'), LitKind::Byte(b'z') | LitKind::Char('z'))
  81             | (LitKind::Byte(b'A') | LitKind::Char('A'), LitKind::Byte(b'Z') | LitKind::Char('Z'))
  82         )
  83         && !in_external_macro(cx.sess(), span)
  84     {
  85         span_lint_and_then(
  86             cx,
  87             ALMOST_COMPLETE_LETTER_RANGE,
  88             span,
  89             "almost complete ascii letter range",
  90             |diag| {
  91                 if let Some((span, sugg)) = sugg {
  92                     diag.span_suggestion(
  93                         span,
  94                         "use an inclusive range",
  95                         sugg,
  96                         Applicability::MaybeIncorrect,
  97                     );
  98                 }
  99             }
 100         );
 101     }
 102 }