prelim lint for unnecessary pattern matching

Author: Jacherr

CHANGELOG.md

@@ -5539,6 +5539,7 @@ Released 2018-09-13
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
 [`unnecessary_owned_empty_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_owned_empty_strings
+[`unnecessary_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_pattern_matching
 [`unnecessary_safety_comment`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_comment
 [`unnecessary_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_doc
 [`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports

clippy_lints/src/declared_lints.rs

@@ -438,6 +438,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::UNNECESSARY_JOIN_INFO,
     crate::methods::UNNECESSARY_LAZY_EVALUATIONS_INFO,
     crate::methods::UNNECESSARY_LITERAL_UNWRAP_INFO,
+    crate::methods::UNNECESSARY_PATTERN_MATCHING_INFO,
     crate::methods::UNNECESSARY_SORT_BY_INFO,
     crate::methods::UNNECESSARY_TO_OWNED_INFO,
     crate::methods::UNWRAP_OR_DEFAULT_INFO,

clippy_lints/src/methods/mod.rs

@@ -106,6 +106,7 @@ mod unnecessary_iter_cloned;
 mod unnecessary_join;
 mod unnecessary_lazy_eval;
 mod unnecessary_literal_unwrap;
+mod unnecessary_pattern_matching;
 mod unnecessary_sort_by;
 mod unnecessary_to_owned;
 mod unwrap_expect_used;
@@ -3683,6 +3684,33 @@ declare_clippy_lint! {
     "calling the `try_from` and `try_into` trait methods when `From`/`Into` is implemented"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Converts some constructs mapping an Enum value for equality comparison.
+    ///
+    /// ### Why is this bad?
+    /// Calls such as `opt.map_or(false, |val| val == 5)` are needlessly long and cumbersome,
+    /// and can be reduced to, for example, `opt == Some(5)` assuming `opt` implements `PartialEq`.
+    /// This lint offers readability and conciseness improvements.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// pub fn a(x: Option<i32>) -> bool {
+    ///     x.map_or(false, |n| n == 5)
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// pub fn a(x: Option<i32>) -> bool {
+    ///     x == Some(5)
+    /// }
+    /// ```
+    #[clippy::version = "1.75.0"]
+    pub UNNECESSARY_PATTERN_MATCHING,
+    style,
+    "reduce unnecessary pattern matching for constructs that implement `PartialEq`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3830,6 +3858,7 @@ impl_lint_pass!(Methods => [
     REDUNDANT_AS_STR,
     WAKER_CLONE_WAKE,
     UNNECESSARY_FALLIBLE_CONVERSIONS,
+    UNNECESSARY_PATTERN_MATCHING,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4290,6 +4319,7 @@ impl Methods {
                 ("map_or", [def, map]) => {
                     option_map_or_none::check(cx, expr, recv, def, map);
                     manual_ok_or::check(cx, expr, recv, def, map);
+                    unnecessary_pattern_matching::check(cx, expr, recv, def, map);
                 },
                 ("next", []) => {
                     if let Some((name2, recv2, args2, _, _)) = method_call(recv) {

clippy_lints/src/methods/unnecessary_pattern_matching.rs

@@ -0,0 +1,57 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::path_to_local_id;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_ast::LitKind::Bool;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind, PatKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::UNNECESSARY_PATTERN_MATCHING;
+
+// Only checking map_or for now
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, def: &Expr<'_>, map: &Expr<'_>) {
+    if let ExprKind::Lit(def_kind) = def.kind
+    // only works on Result and Option
+    && let recv_ty = cx.typeck_results().expr_ty(recv)
+    && (is_type_diagnostic_item(cx, recv_ty, sym::Option)
+        || is_type_diagnostic_item(cx, recv_ty, sym::Result))
+    // check we are dealing with boolean map_or
+    && let Bool(def_bool) = def_kind.node
+    && def_bool == false
+    && let ExprKind::Closure(map_closure) = map.kind
+    && let closure_body = cx.tcx.hir().body(map_closure.body)
+    && let closure_body_value = closure_body.value.peel_blocks()
+    // check we are dealing with equality statement in the closure
+    && let ExprKind::Binary(op, l, r) = closure_body_value.kind
+    && let Some(param) = closure_body.params.first()
+    && let PatKind::Binding(_, hir_id, _, _) = param.pat.kind
+    && BinOpKind::Eq == op.node
+    && (path_to_local_id(l, hir_id) || path_to_local_id(r, hir_id))
+    {
+        let wrap = if is_type_diagnostic_item(cx, recv_ty, sym::Option) {
+            "Some"
+        } else {
+            "Result"
+        };
+
+        // we already checked either l or r is the local id earlier
+        let non_binding_location = if path_to_local_id(l, hir_id) { r } else { l };
+
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_PATTERN_MATCHING,
+            expr.span,
+            "`map_or` here is redundant, use typical equality instead",
+            "try",
+            format!(
+                "{} == {}({})",
+                snippet(cx, recv.span, ".."),
+                wrap,
+                snippet(cx, non_binding_location.span.source_callsite(), "..")
+            ),
+            Applicability::Unspecified,
+        )
+    }
+}

tests/ui/unnecessary_pattern_matching.rs

@@ -0,0 +1,5 @@
+#![warn(clippy::unnecessary_pattern_matching)]
+
+fn main() {
+    // test code goes here
+}