new lint: manual_range_pattern

Author: y21

CHANGELOG.md

@@ -4923,6 +4923,7 @@ Released 2018-09-13
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
+[`manual_range_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_pattern
 [`manual_rem_euclid`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid
 [`manual_retain`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_retain
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic

clippy_lints/src/declared_lints.rs

@@ -277,6 +277,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_let_else::MANUAL_LET_ELSE_INFO,
     crate::manual_main_separator_str::MANUAL_MAIN_SEPARATOR_STR_INFO,
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
+    crate::manual_range_pattern::MANUAL_RANGE_PATTERN_INFO,
     crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
     crate::manual_retain::MANUAL_RETAIN_INFO,
     crate::manual_slice_size_calculation::MANUAL_SLICE_SIZE_CALCULATION_INFO,

clippy_lints/src/lib.rs

@@ -188,6 +188,7 @@ mod manual_is_ascii_check;
 mod manual_let_else;
 mod manual_main_separator_str;
 mod manual_non_exhaustive;
+mod manual_range_pattern;
 mod manual_rem_euclid;
 mod manual_retain;
 mod manual_slice_size_calculation;
@@ -1050,6 +1051,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(large_stack_frames::LargeStackFrames::new(stack_size_threshold)));
     store.register_late_pass(|_| Box::new(single_range_in_vec_init::SingleRangeInVecInit));
     store.register_late_pass(|_| Box::new(incorrect_impls::IncorrectImpls));
+    store.register_late_pass(|_| Box::new(manual_range_pattern::ManualRangePattern));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

clippy_lints/src/manual_range_pattern.rs

@@ -0,0 +1,79 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::LitKind;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_hir::ExprKind;
+use rustc_hir::PatKind;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for combined OR patterns that are all contained in a specific range,
+    /// e.g. `6 | 4 | 5 | 9 | 7 | 8` can be rewritten as `4..=9`.
+    ///
+    /// ### Why is this bad?
+    /// Using an explicit range is more concise and easier to read.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = 6;
+    /// let foo = matches!(x, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = 6;
+    /// let foo = matches!(x, 1..=10);
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub MANUAL_RANGE_PATTERN,
+    complexity,
+    "manually writing range patterns using a combined OR pattern (`|`)"
+}
+declare_lint_pass!(ManualRangePattern => [MANUAL_RANGE_PATTERN]);
+
+impl LateLintPass<'_> for ManualRangePattern {
+    fn check_pat(&mut self, cx: &LateContext<'_>, pat: &'_ rustc_hir::Pat<'_>) {
+        if pat.span.from_expansion() {
+            return;
+        }
+
+        if let PatKind::Or(pats) = pat.kind {
+            let mut min = u128::MAX;
+            let mut max = 0;
+            let mut numbers_found = FxHashSet::default();
+
+            for pat in pats {
+                if let PatKind::Lit(lit) = pat.kind
+                    && let ExprKind::Lit(lit) = lit.kind
+                    && let LitKind::Int(num, _) = lit.node
+                {
+                    numbers_found.insert(num);
+
+                    min = min.min(num);
+                    max = max.max(num);
+                } else {
+                    return;
+                }
+            }
+
+            // a pattern like 1 | 2 seems fine, lint if there are at least 3 alternatives
+            if numbers_found.len() >= 3 {
+                let contains_whole_range = (max - min == numbers_found.len() as u128 - 1)
+                    && (min..=max).all(|num| numbers_found.contains(&num));
+
+                if contains_whole_range {
+                    span_lint_and_sugg(
+                        cx,
+                        MANUAL_RANGE_PATTERN,
+                        pat.span,
+                        "this OR pattern can be rewritten using a range",
+                        "try",
+                        format!("{}..={}", min, max),
+                        Applicability::MachineApplicable,
+                    );
+                }
+            }
+        }
+    }
+}

tests/ui/manual_range_pattern.rs

@@ -0,0 +1,27 @@
+#![allow(unused)]
+#![warn(clippy::manual_range_pattern)]
+
+fn main() {
+    let f = 6;
+
+    let _ = matches!(f, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
+    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
+    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 8 | 10); // 7 is missing
+    let _ = matches!(f, | 4);
+    let _ = matches!(f, 4 | 5);
+    let _ = matches!(f, 1 | 2147483647);
+    let _ = matches!(f, 0 | 2147483647);
+    let _ = matches!(f, -2147483647 | 2147483647);
+    #[allow(clippy::match_like_matches_macro)]
+    let _ = match f {
+        1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
+        _ => false,
+    };
+
+    macro_rules! mac {
+        ($e:expr) => {
+            matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
+        };
+    }
+    mac!(f);
+}

tests/ui/manual_range_pattern.stderr

@@ -0,0 +1,22 @@
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_pattern.rs:7:25
+   |
+LL |     let _ = matches!(f, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+   |
+   = note: `-D clippy::manual-range-pattern` implied by `-D warnings`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_pattern.rs:8:25
+   |
+LL |     let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_pattern.rs:17:9
+   |
+LL |         1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+
+error: aborting due to 3 previous errors
+