From 07b2da884cda8103af50beb327723dec8204fc61 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Tue, 6 Oct 2020 11:49:08 +0200
Subject: [PATCH 1/6] add lint less_concise_than_option_unwrap_or

---
 CHANGELOG.md                            |   1 +
 clippy_lints/src/less_concise_than.rs   | 107 ++++++++++++++++++++++++
 clippy_lints/src/lib.rs                 |   4 +
 clippy_lints/src/option_if_let_else.rs  |  53 +-----------
 clippy_lints/src/utils/eager_or_lazy.rs |   2 +-
 clippy_lints/src/utils/usage.rs         |  50 ++++++++++-
 src/lintlist/mod.rs                     |   7 ++
 tests/ui/less_concise_than.fixed        |  43 ++++++++++
 tests/ui/less_concise_than.rs           |  55 ++++++++++++
 tests/ui/less_concise_than.stderr       |  52 ++++++++++++
 tests/ui/shadow.rs                      |   1 +
 tests/ui/shadow.stderr                  |  46 +++++-----
 12 files changed, 345 insertions(+), 76 deletions(-)
 create mode 100644 clippy_lints/src/less_concise_than.rs
 create mode 100644 tests/ui/less_concise_than.fixed
 create mode 100644 tests/ui/less_concise_than.rs
 create mode 100644 tests/ui/less_concise_than.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f21768c44988..93ce6bb85d8a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1781,6 +1781,7 @@ Released 2018-09-13
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
+[`less_concise_than_option_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#less_concise_than_option_unwrap_or
 [`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
 [`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock
 [`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
diff --git a/clippy_lints/src/less_concise_than.rs b/clippy_lints/src/less_concise_than.rs
new file mode 100644
index 000000000000..097aff4b1786
--- /dev/null
+++ b/clippy_lints/src/less_concise_than.rs
@@ -0,0 +1,107 @@
+use crate::utils;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{def, Arm, Expr, ExprKind, PatKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Finds patterns that can be encoded more concisely with `Option::unwrap_or`.
+    ///
+    /// **Why is this bad?**
+    /// Concise code helps focusing on behavior instead of boilerplate.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// match int_optional {
+    ///     Some(v) => v,
+    ///     None => 1,
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// int_optional.unwrap_or(1)
+    /// ```
+    pub LESS_CONCISE_THAN_OPTION_UNWRAP_OR,
+    pedantic,
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or`"
+}
+
+declare_lint_pass!(LessConciseThan => [LESS_CONCISE_THAN_OPTION_UNWRAP_OR]);
+
+impl LateLintPass<'_> for LessConciseThan {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if utils::in_macro(expr.span) {
+            return;
+        }
+        if lint_option_unwrap_or_case(cx, expr) {
+            return;
+        }
+    }
+}
+
+fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    #[allow(clippy::needless_bool)]
+    fn applicable_none_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
+        if_chain! {
+            if arms.len() == 2;
+            if arms.iter().all(|arm| arm.guard.is_none());
+            if let Some((idx, none_arm)) = arms.iter().enumerate().find(|(_, arm)|
+               if_chain! {
+                    if let PatKind::Path(ref qpath) = arm.pat.kind;
+                    if utils::match_qpath(qpath, &utils::paths::OPTION_NONE);
+                    then { true }
+                    else { false }
+               }
+            );
+            let some_arm = &arms[1 - idx];
+            if let PatKind::TupleStruct(ref some_qpath, &[some_binding], _) = some_arm.pat.kind;
+            if utils::match_qpath(some_qpath, &utils::paths::OPTION_SOME);
+            if let PatKind::Binding(_, binding_hir_id, ..) = some_binding.kind;
+            if let ExprKind::Path(QPath::Resolved(_, body_path)) = some_arm.body.kind;
+            if let def::Res::Local(body_path_hir_id) = body_path.res;
+            if body_path_hir_id == binding_hir_id;
+            then { Some(none_arm) }
+            else { None }
+        }
+    }
+    if_chain! {
+      if !utils::usage::contains_return_break_continue_macro(expr);
+      if let ExprKind::Match (match_expr, match_arms, _) = expr.kind;
+      let ty = cx.typeck_results().expr_ty(match_expr);
+      if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
+      if let Some(none_arm) = applicable_none_arm(match_arms);
+      if let Some(match_expr_snippet) = utils::snippet_opt(cx, match_expr.span);
+      if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
+      if let Some(indent) = utils::indent_of(cx, expr.span);
+      then {
+          let reindented_none_body =
+              utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
+          let eager_eval = utils::eager_or_lazy::is_eagerness_candidate(cx, none_arm.body);
+          let method = if eager_eval {
+              "unwrap_or"
+          } else {
+              "unwrap_or_else"
+          };
+          utils::span_lint_and_sugg(
+              cx,
+              LESS_CONCISE_THAN_OPTION_UNWRAP_OR, expr.span,
+              "this pattern can be more concisely encoded with `Option::unwrap_or`",
+              "replace with",
+              format!(
+                  "{}.{}({}{})",
+                  match_expr_snippet,
+                  method,
+                  if eager_eval { ""} else { "|| " },
+                  reindented_none_body
+              ),
+              Applicability::MachineApplicable,
+          );
+          true
+      } else { false}
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 26a727687b1d..2e9900815d9a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -224,6 +224,7 @@ mod large_const_arrays;
 mod large_enum_variant;
 mod large_stack_arrays;
 mod len_zero;
+mod less_concise_than;
 mod let_if_seq;
 mod let_underscore;
 mod lifetimes;
@@ -609,6 +610,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &large_stack_arrays::LARGE_STACK_ARRAYS,
         &len_zero::LEN_WITHOUT_IS_EMPTY,
         &len_zero::LEN_ZERO,
+        &less_concise_than::LESS_CONCISE_THAN_OPTION_UNWRAP_OR,
         &let_if_seq::USELESS_LET_IF_SEQ,
         &let_underscore::LET_UNDERSCORE_LOCK,
         &let_underscore::LET_UNDERSCORE_MUST_USE,
@@ -1126,6 +1128,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box repeat_once::RepeatOnce);
     store.register_late_pass(|| box unwrap_in_result::UnwrapInResult);
     store.register_late_pass(|| box self_assignment::SelfAssignment);
+    store.register_late_pass(|| box less_concise_than::LessConciseThan);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
     store.register_late_pass(|| box manual_strip::ManualStrip);
@@ -1210,6 +1213,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&infinite_iter::MAYBE_INFINITE_ITER),
         LintId::of(&items_after_statements::ITEMS_AFTER_STATEMENTS),
         LintId::of(&large_stack_arrays::LARGE_STACK_ARRAYS),
+        LintId::of(&less_concise_than::LESS_CONCISE_THAN_OPTION_UNWRAP_OR),
         LintId::of(&literal_representation::LARGE_DIGIT_GROUPS),
         LintId::of(&literal_representation::UNREADABLE_LITERAL),
         LintId::of(&loops::EXPLICIT_INTO_ITER_LOOP),
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 383a62da821e..eb7624b25a3c 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -5,10 +5,8 @@ use crate::utils::{is_type_diagnostic_item, paths, span_lint_and_sugg};
 use if_chain::if_chain;
 
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, PatKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -84,53 +82,6 @@ struct OptionIfLetElseOccurence {
     wrap_braces: bool,
 }
 
-struct ReturnBreakContinueMacroVisitor {
-    seen_return_break_continue: bool,
-}
-
-impl ReturnBreakContinueMacroVisitor {
-    fn new() -> ReturnBreakContinueMacroVisitor {
-        ReturnBreakContinueMacroVisitor {
-            seen_return_break_continue: false,
-        }
-    }
-}
-
-impl<'tcx> Visitor<'tcx> for ReturnBreakContinueMacroVisitor {
-    type Map = Map<'tcx>;
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-
-    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-        if self.seen_return_break_continue {
-            // No need to look farther if we've already seen one of them
-            return;
-        }
-        match &ex.kind {
-            ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => {
-                self.seen_return_break_continue = true;
-            },
-            // Something special could be done here to handle while or for loop
-            // desugaring, as this will detect a break if there's a while loop
-            // or a for loop inside the expression.
-            _ => {
-                if utils::in_macro(ex.span) {
-                    self.seen_return_break_continue = true;
-                } else {
-                    rustc_hir::intravisit::walk_expr(self, ex);
-                }
-            },
-        }
-    }
-}
-
-fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
-    let mut recursive_visitor = ReturnBreakContinueMacroVisitor::new();
-    recursive_visitor.visit_expr(expression);
-    recursive_visitor.seen_return_break_continue
-}
-
 /// Extracts the body of a given arm. If the arm contains only an expression,
 /// then it returns the expression. Otherwise, it returns the entire block
 fn extract_body_from_arm<'a>(arm: &'a Arm<'a>) -> Option<&'a Expr<'a>> {
@@ -208,8 +159,8 @@ fn detect_option_if_let_else<'tcx>(
         if let PatKind::TupleStruct(struct_qpath, &[inner_pat], _) = &arms[0].pat.kind;
         if utils::match_qpath(struct_qpath, &paths::OPTION_SOME);
         if let PatKind::Binding(bind_annotation, _, id, _) = &inner_pat.kind;
-        if !contains_return_break_continue_macro(arms[0].body);
-        if !contains_return_break_continue_macro(arms[1].body);
+        if !utils::usage::contains_return_break_continue_macro(arms[0].body);
+        if !utils::usage::contains_return_break_continue_macro(arms[1].body);
         then {
             let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
             let some_body = extract_body_from_arm(&arms[0])?;
diff --git a/clippy_lints/src/utils/eager_or_lazy.rs b/clippy_lints/src/utils/eager_or_lazy.rs
index 6938d9971d96..30e812c284b0 100644
--- a/clippy_lints/src/utils/eager_or_lazy.rs
+++ b/clippy_lints/src/utils/eager_or_lazy.rs
@@ -82,7 +82,7 @@ fn identify_some_pure_patterns(expr: &Expr<'_>) -> bool {
 /// Identify some potentially computationally expensive patterns.
 /// This function is named so to stress that its implementation is non-exhaustive.
 /// It returns FNs and FPs.
-fn identify_some_potentially_expensive_patterns<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+fn identify_some_potentially_expensive_patterns<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
     // Searches an expression for method calls or function calls that aren't ctors
     struct FunCallFinder<'a, 'tcx> {
         cx: &'a LateContext<'tcx>,
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index ea1dc3be29ba..2fd6046ebcf5 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -1,10 +1,11 @@
+use crate::utils;
 use crate::utils::match_var;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Expr, HirId, Path};
+use rustc_hir::{Expr, ExprKind, HirId, Path};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
@@ -174,3 +175,50 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for BindingUsageFinder<'a, 'tcx> {
         intravisit::NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
     }
 }
+
+struct ReturnBreakContinueMacroVisitor {
+    seen_return_break_continue: bool,
+}
+
+impl ReturnBreakContinueMacroVisitor {
+    fn new() -> ReturnBreakContinueMacroVisitor {
+        ReturnBreakContinueMacroVisitor {
+            seen_return_break_continue: false,
+        }
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for ReturnBreakContinueMacroVisitor {
+    type Map = Map<'tcx>;
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
+        if self.seen_return_break_continue {
+            // No need to look farther if we've already seen one of them
+            return;
+        }
+        match &ex.kind {
+            ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => {
+                self.seen_return_break_continue = true;
+            },
+            // Something special could be done here to handle while or for loop
+            // desugaring, as this will detect a break if there's a while loop
+            // or a for loop inside the expression.
+            _ => {
+                if utils::in_macro(ex.span) {
+                    self.seen_return_break_continue = true;
+                } else {
+                    rustc_hir::intravisit::walk_expr(self, ex);
+                }
+            },
+        }
+    }
+}
+
+pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
+    let mut recursive_visitor = ReturnBreakContinueMacroVisitor::new();
+    recursive_visitor.visit_expr(expression);
+    recursive_visitor.seen_return_break_continue
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 624223ff7062..6dc95fcfdb28 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1075,6 +1075,13 @@ vec![
         deprecation: None,
         module: "len_zero",
     },
+    Lint {
+        name: "less_concise_than_option_unwrap_or",
+        group: "pedantic",
+        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or`",
+        deprecation: None,
+        module: "less_concise_than",
+    },
     Lint {
         name: "let_and_return",
         group: "style",
diff --git a/tests/ui/less_concise_than.fixed b/tests/ui/less_concise_than.fixed
new file mode 100644
index 000000000000..52b69ebba3ec
--- /dev/null
+++ b/tests/ui/less_concise_than.fixed
@@ -0,0 +1,43 @@
+// run-rustfix
+#![warn(clippy::less_concise_than_option_unwrap_or)]
+#![allow(dead_code)]
+
+fn unwrap_or() {
+    // int case
+    Some(1).unwrap_or(42);
+
+    // richer none expr
+    Some(1).unwrap_or_else(|| 1 + 42);
+
+    // multiline case
+    Some(1).unwrap_or_else(|| {
+        let a = 1 + 42;
+        let b = a + 42;
+        b + 42
+    });
+
+    // string case
+    Some("Bob").unwrap_or("Alice");
+
+    // don't lint
+    match Some(1) {
+        Some(i) => i + 2,
+        None => 42,
+    };
+    match Some(1) {
+        Some(i) => i,
+        None => return,
+    };
+    for j in 0..4 {
+        match Some(j) {
+            Some(i) => i,
+            None => continue,
+        };
+        match Some(j) {
+            Some(i) => i,
+            None => break,
+        };
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/less_concise_than.rs b/tests/ui/less_concise_than.rs
new file mode 100644
index 000000000000..bb2a8f2050a9
--- /dev/null
+++ b/tests/ui/less_concise_than.rs
@@ -0,0 +1,55 @@
+// run-rustfix
+#![warn(clippy::less_concise_than_option_unwrap_or)]
+#![allow(dead_code)]
+
+fn unwrap_or() {
+    // int case
+    match Some(1) {
+        Some(i) => i,
+        None => 42,
+    };
+
+    // richer none expr
+    match Some(1) {
+        Some(i) => i,
+        None => 1 + 42,
+    };
+
+    // multiline case
+    match Some(1) {
+        Some(i) => i,
+        None => {
+            let a = 1 + 42;
+            let b = a + 42;
+            b + 42
+        },
+    };
+
+    // string case
+    match Some("Bob") {
+        Some(i) => i,
+        None => "Alice",
+    };
+
+    // don't lint
+    match Some(1) {
+        Some(i) => i + 2,
+        None => 42,
+    };
+    match Some(1) {
+        Some(i) => i,
+        None => return,
+    };
+    for j in 0..4 {
+        match Some(j) {
+            Some(i) => i,
+            None => continue,
+        };
+        match Some(j) {
+            Some(i) => i,
+            None => break,
+        };
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/less_concise_than.stderr b/tests/ui/less_concise_than.stderr
new file mode 100644
index 000000000000..e3e8a406db10
--- /dev/null
+++ b/tests/ui/less_concise_than.stderr
@@ -0,0 +1,52 @@
+error: this pattern can be more concisely encoded with `Option::unwrap_or`
+  --> $DIR/less_concise_than.rs:7:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(i) => i,
+LL | |         None => 42,
+LL | |     };
+   | |_____^ help: replace with: `Some(1).unwrap_or(42)`
+   |
+   = note: `-D clippy::less-concise-than-option-unwrap-or` implied by `-D warnings`
+
+error: this pattern can be more concisely encoded with `Option::unwrap_or`
+  --> $DIR/less_concise_than.rs:13:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(i) => i,
+LL | |         None => 1 + 42,
+LL | |     };
+   | |_____^ help: replace with: `Some(1).unwrap_or_else(|| 1 + 42)`
+
+error: this pattern can be more concisely encoded with `Option::unwrap_or`
+  --> $DIR/less_concise_than.rs:19:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(i) => i,
+LL | |         None => {
+LL | |             let a = 1 + 42;
+...  |
+LL | |         },
+LL | |     };
+   | |_____^
+   |
+help: replace with
+   |
+LL |     Some(1).unwrap_or_else(|| {
+LL |         let a = 1 + 42;
+LL |         let b = a + 42;
+LL |         b + 42
+LL |     });
+   |
+
+error: this pattern can be more concisely encoded with `Option::unwrap_or`
+  --> $DIR/less_concise_than.rs:29:5
+   |
+LL | /     match Some("Bob") {
+LL | |         Some(i) => i,
+LL | |         None => "Alice",
+LL | |     };
+   | |_____^ help: replace with: `Some("Bob").unwrap_or("Alice")`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index bd91ae4e9340..e7441293d457 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -8,6 +8,7 @@
 #![allow(
     unused_parens,
     unused_variables,
+    clippy::less_concise_than_option_unwrap_or,
     clippy::missing_docs_in_private_items,
     clippy::single_match
 )]
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index 8a831375b412..7c1ad2949e91 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -1,135 +1,135 @@
 error: `x` is shadowed by itself in `&mut x`
-  --> $DIR/shadow.rs:26:5
+  --> $DIR/shadow.rs:27:5
    |
 LL |     let x = &mut x;
    |     ^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::shadow-same` implied by `-D warnings`
 note: previous binding is here
-  --> $DIR/shadow.rs:25:13
+  --> $DIR/shadow.rs:26:13
    |
 LL |     let mut x = 1;
    |             ^
 
 error: `x` is shadowed by itself in `{ x }`
-  --> $DIR/shadow.rs:27:5
+  --> $DIR/shadow.rs:28:5
    |
 LL |     let x = { x };
    |     ^^^^^^^^^^^^^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:26:9
+  --> $DIR/shadow.rs:27:9
    |
 LL |     let x = &mut x;
    |         ^
 
 error: `x` is shadowed by itself in `(&*x)`
-  --> $DIR/shadow.rs:28:5
+  --> $DIR/shadow.rs:29:5
    |
 LL |     let x = (&*x);
    |     ^^^^^^^^^^^^^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:27:9
+  --> $DIR/shadow.rs:28:9
    |
 LL |     let x = { x };
    |         ^
 
 error: `x` is shadowed by `{ *x + 1 }` which reuses the original value
-  --> $DIR/shadow.rs:29:9
+  --> $DIR/shadow.rs:30:9
    |
 LL |     let x = { *x + 1 };
    |         ^
    |
    = note: `-D clippy::shadow-reuse` implied by `-D warnings`
 note: initialization happens here
-  --> $DIR/shadow.rs:29:13
+  --> $DIR/shadow.rs:30:13
    |
 LL |     let x = { *x + 1 };
    |             ^^^^^^^^^^
 note: previous binding is here
-  --> $DIR/shadow.rs:28:9
+  --> $DIR/shadow.rs:29:9
    |
 LL |     let x = (&*x);
    |         ^
 
 error: `x` is shadowed by `id(x)` which reuses the original value
-  --> $DIR/shadow.rs:30:9
+  --> $DIR/shadow.rs:31:9
    |
 LL |     let x = id(x);
    |         ^
    |
 note: initialization happens here
-  --> $DIR/shadow.rs:30:13
+  --> $DIR/shadow.rs:31:13
    |
 LL |     let x = id(x);
    |             ^^^^^
 note: previous binding is here
-  --> $DIR/shadow.rs:29:9
+  --> $DIR/shadow.rs:30:9
    |
 LL |     let x = { *x + 1 };
    |         ^
 
 error: `x` is shadowed by `(1, x)` which reuses the original value
-  --> $DIR/shadow.rs:31:9
+  --> $DIR/shadow.rs:32:9
    |
 LL |     let x = (1, x);
    |         ^
    |
 note: initialization happens here
-  --> $DIR/shadow.rs:31:13
+  --> $DIR/shadow.rs:32:13
    |
 LL |     let x = (1, x);
    |             ^^^^^^
 note: previous binding is here
-  --> $DIR/shadow.rs:30:9
+  --> $DIR/shadow.rs:31:9
    |
 LL |     let x = id(x);
    |         ^
 
 error: `x` is shadowed by `first(x)` which reuses the original value
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:33:9
    |
 LL |     let x = first(x);
    |         ^
    |
 note: initialization happens here
-  --> $DIR/shadow.rs:32:13
+  --> $DIR/shadow.rs:33:13
    |
 LL |     let x = first(x);
    |             ^^^^^^^^
 note: previous binding is here
-  --> $DIR/shadow.rs:31:9
+  --> $DIR/shadow.rs:32:9
    |
 LL |     let x = (1, x);
    |         ^
 
 error: `x` is being shadowed
-  --> $DIR/shadow.rs:34:9
+  --> $DIR/shadow.rs:35:9
    |
 LL |     let x = y;
    |         ^
    |
    = note: `-D clippy::shadow-unrelated` implied by `-D warnings`
 note: initialization happens here
-  --> $DIR/shadow.rs:34:13
+  --> $DIR/shadow.rs:35:13
    |
 LL |     let x = y;
    |             ^
 note: previous binding is here
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:33:9
    |
 LL |     let x = first(x);
    |         ^
 
 error: `x` shadows a previous declaration
-  --> $DIR/shadow.rs:36:5
+  --> $DIR/shadow.rs:37:5
    |
 LL |     let x;
    |     ^^^^^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:34:9
+  --> $DIR/shadow.rs:35:9
    |
 LL |     let x = y;
    |         ^

From 9c9327980becadc15a68307705b3a06c28116ae1 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sun, 11 Oct 2020 22:42:45 +0200
Subject: [PATCH 2/6] manual-unwrap-or / rename files

---
 clippy_lints/src/{less_concise_than.rs => manual_unwrap_or.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename clippy_lints/src/{less_concise_than.rs => manual_unwrap_or.rs} (100%)

diff --git a/clippy_lints/src/less_concise_than.rs b/clippy_lints/src/manual_unwrap_or.rs
similarity index 100%
rename from clippy_lints/src/less_concise_than.rs
rename to clippy_lints/src/manual_unwrap_or.rs

From 6d4eeeabcda6d6d25738e1e8e2b64580daefc4b9 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sun, 11 Oct 2020 22:55:05 +0200
Subject: [PATCH 3/6] manual-unwrap-or / pr remarks

---
 CHANGELOG.md                                  |   2 +-
 clippy_lints/src/lib.rs                       |   9 +-
 clippy_lints/src/manual_unwrap_or.rs          | 113 +++++++++---------
 src/lintlist/mod.rs                           |  14 +--
 ...cise_than.fixed => manual_unwrap_or.fixed} |   4 +-
 ...ss_concise_than.rs => manual_unwrap_or.rs} |   7 +-
 ...se_than.stderr => manual_unwrap_or.stderr} |  29 +++--
 tests/ui/shadow.rs                            |   2 +-
 8 files changed, 101 insertions(+), 79 deletions(-)
 rename tests/ui/{less_concise_than.fixed => manual_unwrap_or.fixed} (93%)
 rename tests/ui/{less_concise_than.rs => manual_unwrap_or.rs} (90%)
 rename tests/ui/{less_concise_than.stderr => manual_unwrap_or.stderr} (54%)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 93ce6bb85d8a..d82f970b8bf2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1781,7 +1781,6 @@ Released 2018-09-13
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
-[`less_concise_than_option_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#less_concise_than_option_unwrap_or
 [`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
 [`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock
 [`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
@@ -1797,6 +1796,7 @@ Released 2018-09-13
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
 [`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
+[`manual_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_unwrap_or
 [`many_single_char_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names
 [`map_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_clone
 [`map_entry`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_entry
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2e9900815d9a..d4d2f92a6a69 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -224,7 +224,6 @@ mod large_const_arrays;
 mod large_enum_variant;
 mod large_stack_arrays;
 mod len_zero;
-mod less_concise_than;
 mod let_if_seq;
 mod let_underscore;
 mod lifetimes;
@@ -235,6 +234,7 @@ mod main_recursion;
 mod manual_async_fn;
 mod manual_non_exhaustive;
 mod manual_strip;
+mod manual_unwrap_or;
 mod map_clone;
 mod map_err_ignore;
 mod map_identity;
@@ -610,7 +610,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &large_stack_arrays::LARGE_STACK_ARRAYS,
         &len_zero::LEN_WITHOUT_IS_EMPTY,
         &len_zero::LEN_ZERO,
-        &less_concise_than::LESS_CONCISE_THAN_OPTION_UNWRAP_OR,
         &let_if_seq::USELESS_LET_IF_SEQ,
         &let_underscore::LET_UNDERSCORE_LOCK,
         &let_underscore::LET_UNDERSCORE_MUST_USE,
@@ -642,6 +641,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &manual_async_fn::MANUAL_ASYNC_FN,
         &manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
         &manual_strip::MANUAL_STRIP,
+        &manual_unwrap_or::MANUAL_UNWRAP_OR,
         &map_clone::MAP_CLONE,
         &map_err_ignore::MAP_ERR_IGNORE,
         &map_identity::MAP_IDENTITY,
@@ -1128,7 +1128,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box repeat_once::RepeatOnce);
     store.register_late_pass(|| box unwrap_in_result::UnwrapInResult);
     store.register_late_pass(|| box self_assignment::SelfAssignment);
-    store.register_late_pass(|| box less_concise_than::LessConciseThan);
+    store.register_late_pass(|| box manual_unwrap_or::ManualUnwrapOr);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
     store.register_late_pass(|| box manual_strip::ManualStrip);
@@ -1213,7 +1213,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&infinite_iter::MAYBE_INFINITE_ITER),
         LintId::of(&items_after_statements::ITEMS_AFTER_STATEMENTS),
         LintId::of(&large_stack_arrays::LARGE_STACK_ARRAYS),
-        LintId::of(&less_concise_than::LESS_CONCISE_THAN_OPTION_UNWRAP_OR),
         LintId::of(&literal_representation::LARGE_DIGIT_GROUPS),
         LintId::of(&literal_representation::UNREADABLE_LITERAL),
         LintId::of(&loops::EXPLICIT_INTO_ITER_LOOP),
@@ -1371,6 +1370,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&manual_strip::MANUAL_STRIP),
+        LintId::of(&manual_unwrap_or::MANUAL_UNWRAP_OR),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&map_identity::MAP_IDENTITY),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
@@ -1666,6 +1666,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::MUT_RANGE_BOUND),
         LintId::of(&loops::WHILE_LET_LOOP),
         LintId::of(&manual_strip::MANUAL_STRIP),
+        LintId::of(&manual_unwrap_or::MANUAL_UNWRAP_OR),
         LintId::of(&map_identity::MAP_IDENTITY),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 097aff4b1786..9d8fc863424c 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -2,12 +2,14 @@ use crate::utils;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{def, Arm, Expr, ExprKind, PatKind, QPath};
+use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// **What it does:**
-    /// Finds patterns that can be encoded more concisely with `Option::unwrap_or`.
+    /// Finds patterns that reimplement `Option::unwrap_or`.
     ///
     /// **Why is this bad?**
     /// Concise code helps focusing on behavior instead of boilerplate.
@@ -16,7 +18,7 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// match int_optional {
+    /// match int_option {
     ///     Some(v) => v,
     ///     None => 1,
     /// }
@@ -24,39 +26,35 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     /// ```rust
-    /// int_optional.unwrap_or(1)
+    /// int_option.unwrap_or(1)
     /// ```
-    pub LESS_CONCISE_THAN_OPTION_UNWRAP_OR,
-    pedantic,
-    "finds patterns that can be encoded more concisely with `Option::unwrap_or`"
+    pub MANUAL_UNWRAP_OR,
+    complexity,
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or(_else)`"
 }
 
-declare_lint_pass!(LessConciseThan => [LESS_CONCISE_THAN_OPTION_UNWRAP_OR]);
+declare_lint_pass!(ManualUnwrapOr => [MANUAL_UNWRAP_OR]);
 
-impl LateLintPass<'_> for LessConciseThan {
+impl LateLintPass<'_> for ManualUnwrapOr {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if utils::in_macro(expr.span) {
-            return;
-        }
-        if lint_option_unwrap_or_case(cx, expr) {
+        if in_external_macro(cx.sess(), expr.span) {
             return;
         }
+        lint_option_unwrap_or_case(cx, expr);
     }
 }
 
 fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    #[allow(clippy::needless_bool)]
     fn applicable_none_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
         if_chain! {
             if arms.len() == 2;
             if arms.iter().all(|arm| arm.guard.is_none());
             if let Some((idx, none_arm)) = arms.iter().enumerate().find(|(_, arm)|
-               if_chain! {
-                    if let PatKind::Path(ref qpath) = arm.pat.kind;
-                    if utils::match_qpath(qpath, &utils::paths::OPTION_NONE);
-                    then { true }
-                    else { false }
-               }
+                if let PatKind::Path(ref qpath) = arm.pat.kind {
+                    utils::match_qpath(qpath, &utils::paths::OPTION_NONE)
+                } else {
+                    false
+                }
             );
             let some_arm = &arms[1 - idx];
             if let PatKind::TupleStruct(ref some_qpath, &[some_binding], _) = some_arm.pat.kind;
@@ -65,43 +63,50 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
             if let ExprKind::Path(QPath::Resolved(_, body_path)) = some_arm.body.kind;
             if let def::Res::Local(body_path_hir_id) = body_path.res;
             if body_path_hir_id == binding_hir_id;
-            then { Some(none_arm) }
-            else { None }
+            if !utils::usage::contains_return_break_continue_macro(none_arm.body);
+            then {
+                Some(none_arm)
+            }
+            else {
+                None
+            }
         }
     }
+
     if_chain! {
-      if !utils::usage::contains_return_break_continue_macro(expr);
-      if let ExprKind::Match (match_expr, match_arms, _) = expr.kind;
-      let ty = cx.typeck_results().expr_ty(match_expr);
-      if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
-      if let Some(none_arm) = applicable_none_arm(match_arms);
-      if let Some(match_expr_snippet) = utils::snippet_opt(cx, match_expr.span);
-      if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
-      if let Some(indent) = utils::indent_of(cx, expr.span);
-      then {
-          let reindented_none_body =
-              utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
-          let eager_eval = utils::eager_or_lazy::is_eagerness_candidate(cx, none_arm.body);
-          let method = if eager_eval {
-              "unwrap_or"
-          } else {
-              "unwrap_or_else"
-          };
-          utils::span_lint_and_sugg(
-              cx,
-              LESS_CONCISE_THAN_OPTION_UNWRAP_OR, expr.span,
-              "this pattern can be more concisely encoded with `Option::unwrap_or`",
-              "replace with",
-              format!(
-                  "{}.{}({}{})",
-                  match_expr_snippet,
-                  method,
-                  if eager_eval { ""} else { "|| " },
-                  reindented_none_body
-              ),
-              Applicability::MachineApplicable,
-          );
-          true
-      } else { false}
+        if let ExprKind::Match(scrutinee, match_arms, _) = expr.kind;
+        let ty = cx.typeck_results().expr_ty(scrutinee);
+        if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
+        if let Some(none_arm) = applicable_none_arm(match_arms);
+        if let Some(scrutinee_snippet) = utils::snippet_opt(cx, scrutinee.span);
+        if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
+        if let Some(indent) = utils::indent_of(cx, expr.span);
+        then {
+            let reindented_none_body =
+                utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
+            let eager_eval = utils::eager_or_lazy::is_eagerness_candidate(cx, none_arm.body);
+            let method = if eager_eval {
+                "unwrap_or"
+            } else {
+                "unwrap_or_else"
+            };
+            utils::span_lint_and_sugg(
+                cx,
+                MANUAL_UNWRAP_OR, expr.span,
+                &format!("this pattern reimplements `Option::{}`", &method),
+                "replace with",
+                format!(
+                    "{}.{}({}{})",
+                    scrutinee_snippet,
+                    method,
+                    if eager_eval { ""} else { "|| " },
+                    reindented_none_body
+                ),
+                Applicability::MachineApplicable,
+            );
+            true
+        } else {
+            false
+        }
     }
 }
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6dc95fcfdb28..debd3c31d8bf 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1075,13 +1075,6 @@ vec![
         deprecation: None,
         module: "len_zero",
     },
-    Lint {
-        name: "less_concise_than_option_unwrap_or",
-        group: "pedantic",
-        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or`",
-        deprecation: None,
-        module: "less_concise_than",
-    },
     Lint {
         name: "let_and_return",
         group: "style",
@@ -1187,6 +1180,13 @@ vec![
         deprecation: None,
         module: "swap",
     },
+    Lint {
+        name: "manual_unwrap_or",
+        group: "complexity",
+        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or(_else)`",
+        deprecation: None,
+        module: "manual_unwrap_or",
+    },
     Lint {
         name: "many_single_char_names",
         group: "style",
diff --git a/tests/ui/less_concise_than.fixed b/tests/ui/manual_unwrap_or.fixed
similarity index 93%
rename from tests/ui/less_concise_than.fixed
rename to tests/ui/manual_unwrap_or.fixed
index 52b69ebba3ec..99d30360db1a 100644
--- a/tests/ui/less_concise_than.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -1,11 +1,13 @@
 // run-rustfix
-#![warn(clippy::less_concise_than_option_unwrap_or)]
 #![allow(dead_code)]
 
 fn unwrap_or() {
     // int case
     Some(1).unwrap_or(42);
 
+    // int case reversed
+    Some(1).unwrap_or(42);
+
     // richer none expr
     Some(1).unwrap_or_else(|| 1 + 42);
 
diff --git a/tests/ui/less_concise_than.rs b/tests/ui/manual_unwrap_or.rs
similarity index 90%
rename from tests/ui/less_concise_than.rs
rename to tests/ui/manual_unwrap_or.rs
index bb2a8f2050a9..5d03d9db1639 100644
--- a/tests/ui/less_concise_than.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -1,5 +1,4 @@
 // run-rustfix
-#![warn(clippy::less_concise_than_option_unwrap_or)]
 #![allow(dead_code)]
 
 fn unwrap_or() {
@@ -9,6 +8,12 @@ fn unwrap_or() {
         None => 42,
     };
 
+    // int case reversed
+    match Some(1) {
+        None => 42,
+        Some(i) => i,
+    };
+
     // richer none expr
     match Some(1) {
         Some(i) => i,
diff --git a/tests/ui/less_concise_than.stderr b/tests/ui/manual_unwrap_or.stderr
similarity index 54%
rename from tests/ui/less_concise_than.stderr
rename to tests/ui/manual_unwrap_or.stderr
index e3e8a406db10..03da118a0c42 100644
--- a/tests/ui/less_concise_than.stderr
+++ b/tests/ui/manual_unwrap_or.stderr
@@ -1,5 +1,5 @@
-error: this pattern can be more concisely encoded with `Option::unwrap_or`
-  --> $DIR/less_concise_than.rs:7:5
+error: this pattern reimplements `Option::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:6:5
    |
 LL | /     match Some(1) {
 LL | |         Some(i) => i,
@@ -7,10 +7,19 @@ LL | |         None => 42,
 LL | |     };
    | |_____^ help: replace with: `Some(1).unwrap_or(42)`
    |
-   = note: `-D clippy::less-concise-than-option-unwrap-or` implied by `-D warnings`
+   = note: `-D clippy::manual-unwrap-or` implied by `-D warnings`
 
-error: this pattern can be more concisely encoded with `Option::unwrap_or`
-  --> $DIR/less_concise_than.rs:13:5
+error: this pattern reimplements `Option::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:12:5
+   |
+LL | /     match Some(1) {
+LL | |         None => 42,
+LL | |         Some(i) => i,
+LL | |     };
+   | |_____^ help: replace with: `Some(1).unwrap_or(42)`
+
+error: this pattern reimplements `Option::unwrap_or_else`
+  --> $DIR/manual_unwrap_or.rs:18:5
    |
 LL | /     match Some(1) {
 LL | |         Some(i) => i,
@@ -18,8 +27,8 @@ LL | |         None => 1 + 42,
 LL | |     };
    | |_____^ help: replace with: `Some(1).unwrap_or_else(|| 1 + 42)`
 
-error: this pattern can be more concisely encoded with `Option::unwrap_or`
-  --> $DIR/less_concise_than.rs:19:5
+error: this pattern reimplements `Option::unwrap_or_else`
+  --> $DIR/manual_unwrap_or.rs:24:5
    |
 LL | /     match Some(1) {
 LL | |         Some(i) => i,
@@ -39,8 +48,8 @@ LL |         b + 42
 LL |     });
    |
 
-error: this pattern can be more concisely encoded with `Option::unwrap_or`
-  --> $DIR/less_concise_than.rs:29:5
+error: this pattern reimplements `Option::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:34:5
    |
 LL | /     match Some("Bob") {
 LL | |         Some(i) => i,
@@ -48,5 +57,5 @@ LL | |         None => "Alice",
 LL | |     };
    | |_____^ help: replace with: `Some("Bob").unwrap_or("Alice")`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index e7441293d457..e366c75335c2 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -8,7 +8,7 @@
 #![allow(
     unused_parens,
     unused_variables,
-    clippy::less_concise_than_option_unwrap_or,
+    clippy::manual_unwrap_or,
     clippy::missing_docs_in_private_items,
     clippy::single_match
 )]

From fc846c37fcc720c4a5c2e2075102c1957433e703 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Mon, 12 Oct 2020 00:06:21 +0200
Subject: [PATCH 4/6] manual_unwrap_or / use consts::constant_simple helper

---
 clippy_lints/src/manual_unwrap_or.rs | 11 +++++++----
 tests/ui/manual_unwrap_or.fixed      |  2 +-
 tests/ui/manual_unwrap_or.stderr     |  4 ++--
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 9d8fc863424c..ced941fac1a4 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -1,3 +1,4 @@
+use crate::consts::constant_simple;
 use crate::utils;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -18,15 +19,17 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// match int_option {
+    /// let foo: Option<i32> = None;
+    /// match foo {
     ///     Some(v) => v,
     ///     None => 1,
-    /// }
+    /// };
     /// ```
     ///
     /// Use instead:
     /// ```rust
-    /// int_option.unwrap_or(1)
+    /// let foo: Option<i32> = None;
+    /// foo.unwrap_or(1);
     /// ```
     pub MANUAL_UNWRAP_OR,
     complexity,
@@ -84,7 +87,7 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
         then {
             let reindented_none_body =
                 utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
-            let eager_eval = utils::eager_or_lazy::is_eagerness_candidate(cx, none_arm.body);
+            let eager_eval = constant_simple(cx, cx.typeck_results(), none_arm.body).is_some();
             let method = if eager_eval {
                 "unwrap_or"
             } else {
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index 99d30360db1a..a9cc8678c9d1 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -9,7 +9,7 @@ fn unwrap_or() {
     Some(1).unwrap_or(42);
 
     // richer none expr
-    Some(1).unwrap_or_else(|| 1 + 42);
+    Some(1).unwrap_or(1 + 42);
 
     // multiline case
     Some(1).unwrap_or_else(|| {
diff --git a/tests/ui/manual_unwrap_or.stderr b/tests/ui/manual_unwrap_or.stderr
index 03da118a0c42..8f6835ed78d2 100644
--- a/tests/ui/manual_unwrap_or.stderr
+++ b/tests/ui/manual_unwrap_or.stderr
@@ -18,14 +18,14 @@ LL | |         Some(i) => i,
 LL | |     };
    | |_____^ help: replace with: `Some(1).unwrap_or(42)`
 
-error: this pattern reimplements `Option::unwrap_or_else`
+error: this pattern reimplements `Option::unwrap_or`
   --> $DIR/manual_unwrap_or.rs:18:5
    |
 LL | /     match Some(1) {
 LL | |         Some(i) => i,
 LL | |         None => 1 + 42,
 LL | |     };
-   | |_____^ help: replace with: `Some(1).unwrap_or_else(|| 1 + 42)`
+   | |_____^ help: replace with: `Some(1).unwrap_or(1 + 42)`
 
 error: this pattern reimplements `Option::unwrap_or_else`
   --> $DIR/manual_unwrap_or.rs:24:5

From a8fb69f065a427f5d3fc7222b834cad9a2a7a712 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Tue, 13 Oct 2020 10:24:00 +0200
Subject: [PATCH 5/6] manual-unwrap-or / more pr remarks

---
 clippy_lints/src/manual_unwrap_or.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index ced941fac1a4..719a8b91f669 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -47,7 +47,7 @@ impl LateLintPass<'_> for ManualUnwrapOr {
     }
 }
 
-fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
     fn applicable_none_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
         if_chain! {
             if arms.len() == 2;
@@ -69,8 +69,7 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
             if !utils::usage::contains_return_break_continue_macro(none_arm.body);
             then {
                 Some(none_arm)
-            }
-            else {
+            } else {
                 None
             }
         }
@@ -102,14 +101,11 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
                     "{}.{}({}{})",
                     scrutinee_snippet,
                     method,
-                    if eager_eval { ""} else { "|| " },
+                    if eager_eval { "" } else { "|| " },
                     reindented_none_body
                 ),
                 Applicability::MachineApplicable,
             );
-            true
-        } else {
-            false
         }
     }
 }

From 690a6a6c0eff1a3edeb5f4c2dcbf9994760c3184 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Wed, 14 Oct 2020 22:09:28 +0200
Subject: [PATCH 6/6] manual-unwrap-or / remove unwrap_or_else suggestion due
 to ownership issues

---
 clippy_lints/src/manual_unwrap_or.rs | 17 +++++----------
 src/lintlist/mod.rs                  |  2 +-
 tests/ui/manual_unwrap_or.fixed      | 31 ++++++++++++++++++++++++----
 tests/ui/manual_unwrap_or.rs         | 31 ++++++++++++++++++++++++----
 tests/ui/manual_unwrap_or.stderr     | 18 ++++++++--------
 5 files changed, 69 insertions(+), 30 deletions(-)

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 719a8b91f669..ddb8cc25077e 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     /// ```
     pub MANUAL_UNWRAP_OR,
     complexity,
-    "finds patterns that can be encoded more concisely with `Option::unwrap_or(_else)`"
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or`"
 }
 
 declare_lint_pass!(ManualUnwrapOr => [MANUAL_UNWRAP_OR]);
@@ -83,26 +83,19 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
         if let Some(scrutinee_snippet) = utils::snippet_opt(cx, scrutinee.span);
         if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
         if let Some(indent) = utils::indent_of(cx, expr.span);
+        if constant_simple(cx, cx.typeck_results(), none_arm.body).is_some();
         then {
             let reindented_none_body =
                 utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
-            let eager_eval = constant_simple(cx, cx.typeck_results(), none_arm.body).is_some();
-            let method = if eager_eval {
-                "unwrap_or"
-            } else {
-                "unwrap_or_else"
-            };
             utils::span_lint_and_sugg(
                 cx,
                 MANUAL_UNWRAP_OR, expr.span,
-                &format!("this pattern reimplements `Option::{}`", &method),
+                "this pattern reimplements `Option::unwrap_or`",
                 "replace with",
                 format!(
-                    "{}.{}({}{})",
+                    "{}.unwrap_or({})",
                     scrutinee_snippet,
-                    method,
-                    if eager_eval { "" } else { "|| " },
-                    reindented_none_body
+                    reindented_none_body,
                 ),
                 Applicability::MachineApplicable,
             );
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index debd3c31d8bf..6301d623a2b1 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1183,7 +1183,7 @@ vec![
     Lint {
         name: "manual_unwrap_or",
         group: "complexity",
-        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or(_else)`",
+        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or`",
         deprecation: None,
         module: "manual_unwrap_or",
     },
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index a9cc8678c9d1..a8736f1e6efe 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -12,10 +12,11 @@ fn unwrap_or() {
     Some(1).unwrap_or(1 + 42);
 
     // multiline case
-    Some(1).unwrap_or_else(|| {
-        let a = 1 + 42;
-        let b = a + 42;
-        b + 42
+    #[rustfmt::skip]
+    Some(1).unwrap_or({
+        42 + 42
+            + 42 + 42 + 42
+            + 42 + 42 + 42
     });
 
     // string case
@@ -40,6 +41,28 @@ fn unwrap_or() {
             None => break,
         };
     }
+
+    // cases where the none arm isn't a constant expression
+    // are not linted due to potential ownership issues
+
+    // ownership issue example, don't lint
+    struct NonCopyable;
+    let mut option: Option<NonCopyable> = None;
+    match option {
+        Some(x) => x,
+        None => {
+            option = Some(NonCopyable);
+            // some more code ...
+            option.unwrap()
+        },
+    };
+
+    // ownership issue example, don't lint
+    let option: Option<&str> = None;
+    match option {
+        Some(s) => s,
+        None => &format!("{} {}!", "hello", "world"),
+    };
 }
 
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index 5d03d9db1639..bede8cffc326 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -21,13 +21,14 @@ fn unwrap_or() {
     };
 
     // multiline case
+    #[rustfmt::skip]
     match Some(1) {
         Some(i) => i,
         None => {
-            let a = 1 + 42;
-            let b = a + 42;
-            b + 42
-        },
+            42 + 42
+                + 42 + 42 + 42
+                + 42 + 42 + 42
+        }
     };
 
     // string case
@@ -55,6 +56,28 @@ fn unwrap_or() {
             None => break,
         };
     }
+
+    // cases where the none arm isn't a constant expression
+    // are not linted due to potential ownership issues
+
+    // ownership issue example, don't lint
+    struct NonCopyable;
+    let mut option: Option<NonCopyable> = None;
+    match option {
+        Some(x) => x,
+        None => {
+            option = Some(NonCopyable);
+            // some more code ...
+            option.unwrap()
+        },
+    };
+
+    // ownership issue example, don't lint
+    let option: Option<&str> = None;
+    match option {
+        Some(s) => s,
+        None => &format!("{} {}!", "hello", "world"),
+    };
 }
 
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.stderr b/tests/ui/manual_unwrap_or.stderr
index 8f6835ed78d2..674f2952635f 100644
--- a/tests/ui/manual_unwrap_or.stderr
+++ b/tests/ui/manual_unwrap_or.stderr
@@ -27,29 +27,29 @@ LL | |         None => 1 + 42,
 LL | |     };
    | |_____^ help: replace with: `Some(1).unwrap_or(1 + 42)`
 
-error: this pattern reimplements `Option::unwrap_or_else`
-  --> $DIR/manual_unwrap_or.rs:24:5
+error: this pattern reimplements `Option::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:25:5
    |
 LL | /     match Some(1) {
 LL | |         Some(i) => i,
 LL | |         None => {
-LL | |             let a = 1 + 42;
+LL | |             42 + 42
 ...  |
-LL | |         },
+LL | |         }
 LL | |     };
    | |_____^
    |
 help: replace with
    |
-LL |     Some(1).unwrap_or_else(|| {
-LL |         let a = 1 + 42;
-LL |         let b = a + 42;
-LL |         b + 42
+LL |     Some(1).unwrap_or({
+LL |         42 + 42
+LL |             + 42 + 42 + 42
+LL |             + 42 + 42 + 42
 LL |     });
    |
 
 error: this pattern reimplements `Option::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:34:5
+  --> $DIR/manual_unwrap_or.rs:35:5
    |
 LL | /     match Some("Bob") {
 LL | |         Some(i) => i,