lint on items following statements

3 files changed, 69 insertions, 4 deletions

diff --git a/src/items_after_statements.rs b/src/items_after_statements.rs
new file mode 100644
index 00000000000..5f109dac058
--- /dev/null
+++ b/src/items_after_statements.rs
@@ -0,0 +1,62 @@
+//! lint when items are used after statements
+
+use rustc::lint::*;
+use syntax::attr::*;
+use syntax::ast::*;
+use utils::in_macro;
+
+/// **What it does:** It `Warn`s on blocks where there are items that are declared in the middle of or after the statements
+///
+/// **Why is this bad?** Items live for the entire scope they are declared in. But statements are processed in order. This might cause confusion as it's hard to figure out which item is meant in a statement.
+///
+/// **Known problems:** None
+///
+/// **Example:**
+/// ```rust
+/// fn foo() {
+///     println!("cake");
+/// }
+/// fn main() {
+///     foo(); // prints "foo"
+///     fn foo() {
+///         println!("foo");
+///     }
+///     foo(); // prints "foo"
+/// }
+declare_lint! { pub ITEMS_AFTER_STATEMENTS, Warn, "finds blocks where an item comes after a statement" }
+
+pub struct ItemsAfterStatemets;
+
+impl LintPass for ItemsAfterStatemets {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(ITEMS_AFTER_STATEMENTS)
+    }
+}
+
+impl EarlyLintPass for ItemsAfterStatemets {
+    fn check_block(&mut self, cx: &EarlyContext, item: &Block) {
+        if in_macro(cx, item.span) {
+            return;
+        }
+        let mut stmts = item.stmts.iter().map(|stmt| &stmt.node);
+        // skip initial items
+        while let Some(&StmtDecl(ref decl, _)) = stmts.next() {
+            if let DeclLocal(_) = decl.node {
+                break;
+            }
+        }
+        // lint on all further items
+        for stmt in stmts {
+            if let StmtDecl(ref decl, _) = *stmt {
+                if let DeclItem(ref it) = decl.node {
+                    if in_macro(cx, it.span) {
+                        return;
+                    }
+                    cx.struct_span_lint(ITEMS_AFTER_STATEMENTS, it.span,
+                                        "adding items after statements is confusing, since items exist from the start of the scope")
+                      .emit();
+                }
+            }
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 4a832cc7b89..cd69ac23c19 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -43,6 +43,7 @@ pub mod needless_bool;
 pub mod approx_const;
 pub mod eta_reduction;
 pub mod identity_op;
+pub mod items_after_statements;
 pub mod minmax;
 pub mod mut_mut;
 pub mod mut_reference;
@@ -97,6 +98,7 @@ pub fn plugin_registrar(reg: &mut Registry) {
     reg.register_early_lint_pass(box precedence::Precedence);
     reg.register_late_lint_pass(box eta_reduction::EtaPass);
     reg.register_late_lint_pass(box identity_op::IdentityOp);
+    reg.register_early_lint_pass(box items_after_statements::ItemsAfterStatemets);
     reg.register_late_lint_pass(box mut_mut::MutMut);
     reg.register_late_lint_pass(box mut_reference::UnnecessaryMutPassed);
     reg.register_late_lint_pass(box len_zero::LenZero);
@@ -176,6 +178,7 @@ pub fn plugin_registrar(reg: &mut Registry) {
         escape::BOXED_LOCAL,
         eta_reduction::REDUNDANT_CLOSURE,
         identity_op::IDENTITY_OP,
+        items_after_statements::ITEMS_AFTER_STATEMENTS,
         len_zero::LEN_WITHOUT_IS_EMPTY,
         len_zero::LEN_ZERO,
         lifetimes::NEEDLESS_LIFETIMES,
diff --git a/src/mut_mut.rs b/src/mut_mut.rs
index 1bdb4e9a3d6..4623ca38533 100644
--- a/src/mut_mut.rs
+++ b/src/mut_mut.rs
@@ -37,10 +37,6 @@ impl LateLintPass for MutMut {
 }
 
 fn check_expr_mut(cx: &LateContext, expr: &Expr) {
-    if in_external_macro(cx, expr.span) {
-        return;
-    }
-
     fn unwrap_addr(expr: &Expr) -> Option<&Expr> {
         match expr.node {
             ExprAddrOf(MutMutable, ref e) => Some(e),
@@ -48,6 +44,10 @@ fn check_expr_mut(cx: &LateContext, expr: &Expr) {
         }
     }
 
+    if in_external_macro(cx, expr.span) {
+        return;
+    }
+
     unwrap_addr(expr).map_or((), |e| {
         unwrap_addr(e).map_or_else(|| {
                                        if let TyRef(_, TypeAndMut{mutbl: MutMutable, ..}) = cx.tcx.expr_ty(e).sty {