Collapse nested if-statements.

Author: Arc8ne

clippy_lints/src/collapsible_if.rs

@@ -81,69 +81,65 @@ declare_clippy_lint! {
 }
 
 fn check_collapsible_if_nested_if_else(cx: &LateContext<'_>, if_expr: &Expr<'_>) {
-    if let ExprKind::If(cond, then, else_opt) = if_expr.kind {
-        if let ExprKind::Block(then_block, _) = then.kind {
-            if let Some(then_expr) = then_block.expr {
-                if let ExprKind::If(inner_cond, inner_then, _) = then_expr.kind {
-                    if let Some(else_expr) = else_opt {
-                        let mut spanless_eq = SpanlessEq::new(cx);
+    if let ExprKind::If(cond, then, else_opt) = if_expr.kind &&
+    let ExprKind::Block(then_block, _) = then.kind &&
+    let Some(then_expr) = then_block.expr &&
+    let ExprKind::If(inner_cond, inner_then, _) = then_expr.kind &&
+    let Some(else_expr) = else_opt {
+        let mut spanless_eq = SpanlessEq::new(cx);
 
-                        if !spanless_eq.eq_expr(inner_then, else_expr) {
-                            return;
-                        }
-
-                        let mut cond_sugg = Sugg::NonParen(Cow::Borrowed(""));
+        if !spanless_eq.eq_expr(inner_then, else_expr) {
+            return;
+        }
 
-                        if let ExprKind::DropTemps(cond_expr) = cond.kind {
-                            match cond_expr.kind {
-                                ExprKind::Binary(bin_op, lhs, rhs) => {
-                                    let new_bin_op;
+        let mut cond_sugg = Sugg::NonParen(Cow::Borrowed(""));
 
-                                    if let BinOpKind::Ne = bin_op.node {
-                                        new_bin_op = BinOpKind::Eq;
-                                    } else {
-                                        new_bin_op = BinOpKind::Ne;
-                                    }
+        if let ExprKind::DropTemps(cond_expr) = cond.kind {
+            match cond_expr.kind {
+                ExprKind::Binary(bin_op, lhs, rhs) => {
+                    let new_bin_op;
 
-                                    cond_sugg =
-                                        make_binop(new_bin_op, &Sugg::hir(cx, lhs, ".."), &Sugg::hir(cx, rhs, ".."));
-                                },
-                                ExprKind::Unary(un_op, expr) => {
-                                    if let UnOp::Not = un_op {
-                                        cond_sugg = Sugg::hir(cx, expr, "..");
-                                    }
-                                },
-                                ExprKind::Path(_) => {
-                                    cond_sugg = make_unop("!", Sugg::hir(cx, cond_expr, ".."));
-                                },
-                                _ => {},
-                            }
-                        } else {
-                            cond_sugg = make_unop("!", Sugg::hir(cx, cond, ".."));
-                        }
+                    if let BinOpKind::Ne = bin_op.node {
+                        new_bin_op = BinOpKind::Eq;
+                    } else {
+                        new_bin_op = BinOpKind::Ne;
+                    }
 
-                        span_lint_and_then(
-                            cx,
-                            COLLAPSIBLE_IF,
-                            if_expr.span,
-                            "this `if` statement can be collapsed.",
-                            |diag| {
-                                diag.span_suggestion(
-                                    if_expr.span,
-                                    "collapse else and nested if blocks",
-                                    format!(
-                                        "if {} {}",
-                                        make_binop(BinOpKind::Or, &cond_sugg, &Sugg::hir(cx, inner_cond, "..")),
-                                        Sugg::hir(cx, else_expr, "..")
-                                    ),
-                                    Applicability::MachineApplicable,
-                                );
-                            },
-                        );
+                    cond_sugg =
+                        make_binop(new_bin_op, &Sugg::hir(cx, lhs, ".."), &Sugg::hir(cx, rhs, ".."));
+                },
+                ExprKind::Unary(un_op, expr) => {
+                    if let UnOp::Not = un_op {
+                        cond_sugg = Sugg::hir(cx, expr, "..");
                     }
-                }
+                },
+                ExprKind::Path(_) => {
+                    cond_sugg = make_unop("!", Sugg::hir(cx, cond_expr, ".."));
+                },
+                _ => {},
             }
+        } else {
+            cond_sugg = make_unop("!", Sugg::hir(cx, cond, ".."));
         }
+
+        span_lint_and_then(
+            cx,
+            COLLAPSIBLE_IF,
+            if_expr.span,
+            "this `if` statement can be collapsed.",
+            |diag| {
+                diag.span_suggestion(
+                    if_expr.span,
+                    "collapse else and nested if blocks",
+                    format!(
+                        "if {} {}",
+                        make_binop(BinOpKind::Or, &cond_sugg, &Sugg::hir(cx, inner_cond, "..")),
+                        Sugg::hir(cx, else_expr, "..")
+                    ),
+                    Applicability::MachineApplicable,
+                );
+            },
+        );
     }
 }