Add block_in_if lint, #434

src/block_in_if_condition.rs

@@ -0,0 +1,91 @@
+use rustc_front::hir::*;
+use rustc::lint::{LateLintPass, LateContext, LintArray, LintPass};
+use rustc_front::intravisit::{Visitor, walk_expr};
+use utils::*;
+
+declare_lint! {
+    pub BLOCK_IN_IF_CONDITION_EXPR, Warn,
+    "braces can be eliminated in conditions that are expressions, e.g `if { true } ...`"
+}
+
+declare_lint! {
+    pub BLOCK_IN_IF_CONDITION_STMT, Warn,
+    "avoid complex blocks in conditions, instead move the block higher and bind it \
+    with 'let'; e.g: `if { let x = true; x } ...`"
+}
+
+#[derive(Copy,Clone)]
+pub struct BlockInIfCondition;
+
+impl LintPass for BlockInIfCondition {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(BLOCK_IN_IF_CONDITION_EXPR, BLOCK_IN_IF_CONDITION_STMT)
+    }
+}
+
+struct ExVisitor<'v> {
+    found_block: Option<&'v Expr>
+}
+
+impl<'v> Visitor<'v> for ExVisitor<'v> {
+    fn visit_expr(&mut self, expr: &'v Expr) {
+        if let ExprClosure(_, _, ref block) = expr.node {
+            let complex = {
+                if !block.stmts.is_empty() {
+                    true
+                } else {
+                    if let Some(ref ex) = block.expr {
+                        match ex.node {
+                            ExprBlock(_) => true,
+                            _ => false
+                        }
+                    } else {
+                        false
+                    }
+                }
+            };
+            if complex {
+                self.found_block = Some(& expr);
+                return;
+            }
+        }
+        walk_expr(self, expr);
+    }
+}
+
+const BRACED_EXPR_MESSAGE:&'static str = "omit braces around single expression condition";
+const COMPLEX_BLOCK_MESSAGE:&'static str = "in an 'if' condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a 'let'";
+
+impl LateLintPass for BlockInIfCondition {
+    fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
+        if let ExprIf(ref check, ref then, _) = expr.node {
+            if let ExprBlock(ref block) = check.node {
+                if block.stmts.is_empty() {
+                    if let Some(ref ex) = block.expr {
+                        // don't dig into the expression here, just suggest that they remove
+                        // the block
+
+                        span_help_and_lint(cx, BLOCK_IN_IF_CONDITION_EXPR, check.span,
+                            BRACED_EXPR_MESSAGE,
+                            &format!("try\nif {} {} ... ", snippet_block(cx, ex.span, ".."),
+                            snippet_block(cx, then.span, "..")));
+                    }
+                } else {
+                    // move block higher
+                    span_help_and_lint(cx, BLOCK_IN_IF_CONDITION_STMT, check.span,
+                        COMPLEX_BLOCK_MESSAGE,
+                        &format!("try\nlet res = {};\nif res {} ... ",
+                        snippet_block(cx, block.span, ".."),
+                        snippet_block(cx, then.span, "..")));
+                }
+            } else {
+                let mut visitor = ExVisitor { found_block: None };
+                walk_expr(&mut visitor, check);
+                if let Some(ref block) = visitor.found_block {
+                    span_help_and_lint(cx, BLOCK_IN_IF_CONDITION_STMT, block.span,
+                        COMPLEX_BLOCK_MESSAGE, "");
+                }
+            }
+        }
+    }
+}

src/lib.rs

@@ -37,6 +37,7 @@ pub mod mut_reference;
 pub mod len_zero;
 pub mod attrs;
 pub mod collapsible_if;
+pub mod block_in_if_condition;
 pub mod unicode;
 pub mod shadow;
 pub mod strings;
@@ -81,6 +82,7 @@ pub fn plugin_registrar(reg: &mut Registry) {
     reg.register_late_lint_pass(box misc::CmpOwned);
     reg.register_late_lint_pass(box attrs::AttrPass);
     reg.register_late_lint_pass(box collapsible_if::CollapsibleIf);
+    reg.register_late_lint_pass(box block_in_if_condition::BlockInIfCondition);
     reg.register_late_lint_pass(box misc::ModuloOne);
     reg.register_late_lint_pass(box unicode::Unicode);
     reg.register_late_lint_pass(box strings::StringAdd);
@@ -131,6 +133,8 @@ pub fn plugin_registrar(reg: &mut Registry) {
         attrs::INLINE_ALWAYS,
         bit_mask::BAD_BIT_MASK,
         bit_mask::INEFFECTIVE_BIT_MASK,
+        block_in_if_condition::BLOCK_IN_IF_CONDITION_EXPR,
+        block_in_if_condition::BLOCK_IN_IF_CONDITION_STMT,
         collapsible_if::COLLAPSIBLE_IF,
         eq_op::EQ_OP,
         eta_reduction::REDUNDANT_CLOSURE,