Fix dogfooding test errors

1 files changed, 85 insertions, 87 deletions

diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index b44089f7bfc..a3e7e9971f8 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -6,6 +6,66 @@ use rustc_lint::LateContext;
 
 use super::UNNECESSARY_LAZY_EVALUATION;
 
+// Return true if the expression is an accessor of any of the arguments
+fn expr_uses_argument(expr: &hir::Expr<'_>, params: &[hir::Param<'_>]) -> bool {
+    params.iter().any(|arg| {
+        if_chain! {
+            if let hir::PatKind::Binding(_, _, ident, _) = arg.pat.kind;
+            if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.kind;
+            if let [p, ..] = path.segments;
+            then {
+                ident.name == p.ident.name
+            } else {
+                false
+            }
+        }
+    })
+}
+
+fn match_any_qpath(path: &hir::QPath<'_>, paths: &[&[&str]]) -> bool {
+    paths.iter().any(|candidate| match_qpath(path, candidate))
+}
+
+fn can_simplify(expr: &hir::Expr<'_>, params: &[hir::Param<'_>], variant_calls: bool) -> bool {
+    match expr.kind {
+        // Closures returning literals can be unconditionally simplified
+        hir::ExprKind::Lit(_) => true,
+
+        hir::ExprKind::Index(ref object, ref index) => {
+            // arguments are not being indexed into
+            if expr_uses_argument(object, params) {
+                false
+            } else {
+                // arguments are not used as index
+                !expr_uses_argument(index, params)
+            }
+        },
+
+        // Reading fields can be simplified if the object is not an argument of the closure
+        hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
+
+        // Paths can be simplified if the root is not the argument, this also covers None
+        hir::ExprKind::Path(_) => !expr_uses_argument(expr, params),
+
+        // Calls to Some, Ok, Err can be considered literals if they don't derive an argument
+        hir::ExprKind::Call(ref func, ref args) => if_chain! {
+            if variant_calls; // Disable lint when rules conflict with bind_instead_of_map
+            if let hir::ExprKind::Path(ref path) = func.kind;
+            if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
+            then {
+                // Recursively check all arguments
+                args.iter().all(|arg| can_simplify(arg, params, variant_calls))
+            } else {
+                false
+            }
+        },
+
+        // For anything more complex than the above, a closure is probably the right solution,
+        // or the case is handled by an other lint
+        _ => false,
+    }
+}
+
 /// lint use of `<fn>_else(simple closure)` for `Option`s and `Result`s that can be
 /// replaced with `<fn>(return value of simple closure)`
 pub(super) fn lint<'tcx>(
@@ -18,96 +78,34 @@ pub(super) fn lint<'tcx>(
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(option_type));
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(result_type));
 
-    if !is_option && !is_result {
-        return;
-    }
-
-    // Return true if the expression is an accessor of any of the arguments
-    fn expr_uses_argument(expr: &hir::Expr<'_>, params: &[hir::Param<'_>]) -> bool {
-        params.iter().any(|arg| {
-            if_chain! {
-                if let hir::PatKind::Binding(_, _, ident, _) = arg.pat.kind;
-                if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.kind;
-                if let [p, ..] = path.segments;
-                then {
-                    ident.name == p.ident.name
-                } else {
-                    false
-                }
-            }
-        })
-    }
+    if is_option || is_result {
+        if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
+            let body = cx.tcx.hir().body(eid);
+            let ex = &body.value;
+            let params = &body.params;
 
-    fn match_any_qpath(path: &hir::QPath<'_>, paths: &[&[&str]]) -> bool {
-        paths.iter().any(|candidate| match_qpath(path, candidate))
-    }
-
-    fn can_simplify(expr: &hir::Expr<'_>, params: &[hir::Param<'_>], variant_calls: bool) -> bool {
-        match expr.kind {
-            // Closures returning literals can be unconditionally simplified
-            hir::ExprKind::Lit(_) => true,
-
-            hir::ExprKind::Index(ref object, ref index) => {
-                // arguments are not being indexed into
-                if !expr_uses_argument(object, params) {
-                    // arguments are not used as index
-                    !expr_uses_argument(index, params)
+            if can_simplify(ex, params, allow_variant_calls) {
+                let msg = if is_option {
+                    "unnecessary closure used to substitute value for `Option::None`"
                 } else {
-                    false
-                }
-            },
-
-            // Reading fields can be simplified if the object is not an argument of the closure
-            hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
-
-            // Paths can be simplified if the root is not the argument, this also covers None
-            hir::ExprKind::Path(_) => !expr_uses_argument(expr, params),
+                    "unnecessary closure used to substitute value for `Result::Err`"
+                };
 
-            // Calls to Some, Ok, Err can be considered literals if they don't derive an argument
-            hir::ExprKind::Call(ref func, ref args) => if_chain! {
-                if variant_calls; // Disable lint when rules conflict with bind_instead_of_map
-                if let hir::ExprKind::Path(ref path) = func.kind;
-                if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
-                then {
-                    // Recursively check all arguments
-                    args.iter().all(|arg| can_simplify(arg, params, variant_calls))
-                } else {
-                    false
-                }
-            },
-
-            // For anything more complex than the above, a closure is probably the right solution,
-            // or the case is handled by an other lint
-            _ => false,
-        }
-    }
-
-    if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
-        let body = cx.tcx.hir().body(eid);
-        let ex = &body.value;
-        let params = &body.params;
-
-        if can_simplify(ex, params, allow_variant_calls) {
-            let msg = if is_option {
-                "unnecessary closure used to substitute value for `Option::None`"
-            } else {
-                "unnecessary closure used to substitute value for `Result::Err`"
-            };
-
-            span_lint_and_sugg(
-                cx,
-                UNNECESSARY_LAZY_EVALUATION,
-                expr.span,
-                msg,
-                &format!("Use `{}` instead", simplify_using),
-                format!(
-                    "{0}.{1}({2})",
-                    snippet(cx, args[0].span, ".."),
-                    simplify_using,
-                    snippet(cx, ex.span, ".."),
-                ),
-                Applicability::MachineApplicable,
-            );
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_LAZY_EVALUATION,
+                    expr.span,
+                    msg,
+                    &format!("Use `{}` instead", simplify_using),
+                    format!(
+                        "{0}.{1}({2})",
+                        snippet(cx, args[0].span, ".."),
+                        simplify_using,
+                        snippet(cx, ex.span, ".."),
+                    ),
+                    Applicability::MachineApplicable,
+                );
+            }
         }
     }
 }