Merge pull request #1054 from Manishearth/rustup

mcarton · web-flow · commit d243d686fd9d · 2016-07-02T16:15:57.000+02:00
Rustup to ea0dc92
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,7 +1,8 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## 0.0.78 - TBA
+## 0.0.78 - 2016-07-02
+* Rustup to *rustc 1.11.0-nightly (01411937f 2016-07-01)*
 * New lints: [`wrong_transmute`, `double_neg`]
 * For compatibility, `cargo clippy` does not defines the `clippy` feature
   introduced in 0.0.76 anymore
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy"
-version = "0.0.77"
+version = "0.0.78"
 authors = [
 	"Manish Goregaokar <manishsmail@gmail.com>",
 	"Andre Bogus <bogusandre@gmail.com>",
@@ -25,7 +25,7 @@ test = false
 
 [dependencies]
 # begin automatic update
-clippy_lints = { version = "0.0.77", path = "clippy_lints" }
+clippy_lints = { version = "0.0.78", path = "clippy_lints" }
 # end automatic update
 
 [dev-dependencies]
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "clippy_lints"
 # begin automatic update
-version = "0.0.77"
+version = "0.0.78"
 # end automatic update
 authors = [
 	"Manish Goregaokar <manishsmail@gmail.com>",
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
@@ -3,6 +3,7 @@ use rustc::hir::*;
 use rustc::hir::intravisit::*;
 use syntax::ast::{LitKind, DUMMY_NODE_ID};
 use syntax::codemap::{DUMMY_SP, dummy_spanned};
+use syntax::util::ThinVec;
 use utils::{span_lint_and_then, in_macro, snippet_opt, SpanlessEq};
 
 /// **What it does:** This lint checks for boolean expressions that can be written more concisely
@@ -99,7 +100,7 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
                         Expr {
                             id: DUMMY_NODE_ID,
                             span: DUMMY_SP,
-                            attrs: None,
+                            attrs: ThinVec::new(),
                             node: ExprBinary(dummy_spanned(op), lhs.clone(), rhs.clone()),
                         }
                     };
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
@@ -72,8 +72,8 @@ fn check_if(cx: &EarlyContext, expr: &ast::Expr) {
 fn check_collapsible_maybe_if_let(cx: &EarlyContext, else_: &ast::Expr) {
     if_let_chain! {[
         let ast::ExprKind::Block(ref block) = else_.node,
-        block.stmts.is_empty(),
-        let Some(ref else_) = block.expr,
+        let Some(ref else_) = expr_block(block),
+        !in_macro(cx, else_.span),
     ], {
         match else_.node {
             ast::ExprKind::If(..) | ast::ExprKind::IfLet(..) => {
@@ -96,7 +96,7 @@ fn check_collapsible_no_if_let(
     then: &ast::Block,
 ) {
     if_let_chain! {[
-        let Some(inner) = single_stmt_of_block(then),
+        let Some(inner) = expr_block(then),
         let ast::ExprKind::If(ref check_inner, ref content, None) = inner.node,
     ], {
         if expr.span.expn_id != inner.span.expn_id {
@@ -128,28 +128,16 @@ fn check_to_string(cx: &EarlyContext, e: &ast::Expr) -> Cow<'static, str> {
     }
 }
 
-fn single_stmt_of_block(block: &ast::Block) -> Option<&ast::Expr> {
-    if block.stmts.len() == 1 && block.expr.is_none() {
-        if let ast::StmtKind::Expr(ref expr, _) = block.stmts[0].node {
-            single_stmt_of_expr(expr)
-        } else {
-            None
-        }
-    } else if block.stmts.is_empty() {
-        if let Some(ref p) = block.expr {
-            Some(p)
-        } else {
-            None
+/// If the block contains only one expression, returns it.
+fn expr_block(block: &ast::Block) -> Option<&ast::Expr> {
+    let mut it = block.stmts.iter();
+
+    if let (Some(stmt), None) = (it.next(), it.next()) {
+        match stmt.node {
+            ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => Some(expr),
+            _ => None,
         }
     } else {
         None
     }
 }
-
-fn single_stmt_of_expr(expr: &ast::Expr) -> Option<&ast::Expr> {
-    if let ast::ExprKind::Block(ref block) = expr.node {
-        single_stmt_of_block(block)
-    } else {
-        Some(expr)
-    }
-}
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
@@ -59,21 +59,13 @@ impl EarlyLintPass for Formatting {
     fn check_block(&mut self, cx: &EarlyContext, block: &ast::Block) {
         for w in block.stmts.windows(2) {
             match (&w[0].node, &w[1].node) {
-                (&ast::StmtKind::Expr(ref first, _), &ast::StmtKind::Expr(ref second, _)) |
-                (&ast::StmtKind::Expr(ref first, _), &ast::StmtKind::Semi(ref second, _)) => {
+                (&ast::StmtKind::Expr(ref first), &ast::StmtKind::Expr(ref second)) |
+                (&ast::StmtKind::Expr(ref first), &ast::StmtKind::Semi(ref second)) => {
                     check_consecutive_ifs(cx, first, second);
                 }
                 _ => (),
             }
         }
-
-        if let Some(ref expr) = block.expr {
-            if let Some(ref stmt) = block.stmts.iter().last() {
-                if let ast::StmtKind::Expr(ref first, _) = stmt.node {
-                    check_consecutive_ifs(cx, first, expr);
-                }
-            }
-        }
     }
 
     fn check_expr(&mut self, cx: &EarlyContext, expr: &ast::Expr) {
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
@@ -2,7 +2,7 @@
 
 use rustc::lint::*;
 use syntax::ast::*;
-use utils::in_macro;
+use utils::{in_macro, span_lint};
 
 /// **What it does:** This lints checks for items declared after some statement in a block
 ///
@@ -44,26 +44,23 @@ impl EarlyLintPass for ItemsAfterStatements {
         if in_macro(cx, item.span) {
             return;
         }
-        let mut stmts = item.stmts.iter().map(|stmt| &stmt.node);
+
         // skip initial items
-        while let Some(&StmtKind::Decl(ref decl, _)) = stmts.next() {
-            if let DeclKind::Local(_) = decl.node {
-                break;
-            }
-        }
+        let stmts = item.stmts.iter()
+                              .map(|stmt| &stmt.node)
+                              .skip_while(|s| matches!(**s, StmtKind::Item(..)));
+
         // lint on all further items
         for stmt in stmts {
-            if let StmtKind::Decl(ref decl, _) = *stmt {
-                if let DeclKind::Item(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();
+            if let StmtKind::Item(ref it) = *stmt {
+                if in_macro(cx, it.span) {
+                    return;
                 }
+                span_lint(cx,
+                          ITEMS_AFTER_STATEMENTS,
+                          it.span,
+                          "adding items after statements is confusing, since items exist from the \
+                           start of the scope");
             }
         }
     }
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
@@ -171,15 +171,14 @@ impl EarlyLintPass for MiscEarly {
     fn check_block(&mut self, cx: &EarlyContext, block: &Block) {
         for w in block.stmts.windows(2) {
             if_let_chain! {[
-                let StmtKind::Decl(ref first, _) = w[0].node,
-                let DeclKind::Local(ref local) = first.node,
+                let StmtKind::Local(ref local) = w[0].node,
                 let Option::Some(ref t) = local.init,
-                let ExprKind::Closure(_,_,_,_) = t.node,
-                let PatKind::Ident(_,sp_ident,_) = local.pat.node,
-                let StmtKind::Semi(ref second,_) = w[1].node,
-                let ExprKind::Assign(_,ref call) = second.node,
-                let ExprKind::Call(ref closure,_) = call.node,
-                let ExprKind::Path(_,ref path) = closure.node
+                let ExprKind::Closure(_, _, _, _) = t.node,
+                let PatKind::Ident(_, sp_ident, _) = local.pat.node,
+                let StmtKind::Semi(ref second) = w[1].node,
+                let ExprKind::Assign(_, ref call) = second.node,
+                let ExprKind::Call(ref closure, _) = call.node,
+                let ExprKind::Path(_, ref path) = closure.node
             ], {
                 if sp_ident.node == (&path.segments[0]).identifier {
                     span_lint(cx, REDUNDANT_CLOSURE_CALL, second.span, "Closure called just once immediately after it was declared");
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
@@ -68,8 +68,8 @@ const WHITELIST: &'static [&'static [&'static str]] = &[
 
 struct SimilarNamesNameVisitor<'a, 'b: 'a, 'c: 'b>(&'a mut SimilarNamesLocalVisitor<'b, 'c>);
 
-impl<'v, 'a, 'b, 'c> Visitor<'v> for SimilarNamesNameVisitor<'a, 'b, 'c> {
-    fn visit_pat(&mut self, pat: &'v Pat) {
+impl<'a, 'b, 'c> Visitor for SimilarNamesNameVisitor<'a, 'b, 'c> {
+    fn visit_pat(&mut self, pat: &Pat) {
         match pat.node {
             PatKind::Ident(_, id, _) => self.check_name(id.span, id.node.name),
             PatKind::Struct(_, ref fields, _) => {
@@ -226,25 +226,25 @@ impl<'a, 'b> SimilarNamesLocalVisitor<'a, 'b> {
     }
 }
 
-impl<'v, 'a, 'b> Visitor<'v> for SimilarNamesLocalVisitor<'a, 'b> {
-    fn visit_local(&mut self, local: &'v Local) {
+impl<'a, 'b> Visitor for SimilarNamesLocalVisitor<'a, 'b> {
+    fn visit_local(&mut self, local: &Local) {
         if let Some(ref init) = local.init {
             self.apply(|this| walk_expr(this, &**init));
         }
         // add the pattern after the expression because the bindings aren't available yet in the init expression
         SimilarNamesNameVisitor(self).visit_pat(&*local.pat);
     }
-    fn visit_block(&mut self, blk: &'v Block) {
+    fn visit_block(&mut self, blk: &Block) {
         self.apply(|this| walk_block(this, blk));
     }
-    fn visit_arm(&mut self, arm: &'v Arm) {
+    fn visit_arm(&mut self, arm: &Arm) {
         self.apply(|this| {
             // just go through the first pattern, as either all patterns bind the same bindings or rustc would have errored much earlier
             SimilarNamesNameVisitor(this).visit_pat(&arm.pats[0]);
             this.apply(|this| walk_expr(this, &arm.body));
         });
     }
-    fn visit_item(&mut self, _: &'v Item) {
+    fn visit_item(&mut self, _: &Item) {
         // do not recurse into inner items
     }
 }
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
@@ -36,13 +36,12 @@ pub struct ReturnPass;
 impl ReturnPass {
     // Check the final stmt or expr in a block for unnecessary return.
     fn check_block_return(&mut self, cx: &EarlyContext, block: &Block) {
-        if let Some(ref expr) = block.expr {
-            self.check_final_expr(cx, expr);
-        } else if let Some(stmt) = block.stmts.last() {
-            if let StmtKind::Semi(ref expr, _) = stmt.node {
-                if let ExprKind::Ret(Some(ref inner)) = expr.node {
-                    self.emit_return_lint(cx, (stmt.span, inner.span));
+        if let Some(stmt) = block.stmts.last() {
+            match stmt.node {
+                StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
+                    self.check_final_expr(cx, expr);
                 }
+                _ => (),
             }
         }
     }
@@ -88,12 +87,14 @@ impl ReturnPass {
 
     // Check for "let x = EXPR; x"
     fn check_let_return(&mut self, cx: &EarlyContext, block: &Block) {
+        let mut it = block.stmts.iter();
+
         // we need both a let-binding stmt and an expr
         if_let_chain! {[
-            let Some(stmt) = block.stmts.last(),
-            let Some(ref retexpr) = block.expr,
-            let StmtKind::Decl(ref decl, _) = stmt.node,
-            let DeclKind::Local(ref local) = decl.node,
+            let Some(ref retexpr) = it.next_back(),
+            let StmtKind::Expr(ref retexpr) = retexpr.node,
+            let Some(stmt) = it.next_back(),
+            let StmtKind::Local(ref local) = stmt.node,
             let Some(ref initexpr) = local.init,
             let PatKind::Ident(_, Spanned { node: id, .. }, _) = local.pat.node,
             let ExprKind::Path(_, ref path) = retexpr.node,
diff --git a/mini-macro/src/lib.rs b/mini-macro/src/lib.rs
@@ -5,7 +5,7 @@ extern crate rustc;
 extern crate rustc_plugin;
 
 use syntax::codemap::Span;
-use syntax::ast::TokenTree;
+use syntax::tokenstream::TokenTree;
 use syntax::ext::base::{ExtCtxt, MacResult, MacEager};
 use syntax::ext::build::AstBuilder;  // trait for expr_usize
 use rustc_plugin::Registry;
diff --git a/src/main.rs b/src/main.rs
@@ -2,17 +2,17 @@
 #![feature(box_syntax)]
 #![feature(rustc_private)]
 
-extern crate rustc_driver;
+extern crate clippy_lints;
 extern crate getopts;
 extern crate rustc;
-extern crate syntax;
+extern crate rustc_driver;
+extern crate rustc_errors;
 extern crate rustc_plugin;
-extern crate clippy_lints;
+extern crate syntax;
 
 use rustc_driver::{driver, CompilerCalls, RustcDefaultCalls, Compilation};
 use rustc::session::{config, Session};
 use rustc::session::config::{Input, ErrorOutputType};
-use syntax::diagnostics;
 use std::path::PathBuf;
 use std::process::Command;
 
@@ -36,7 +36,7 @@ impl<'a> CompilerCalls<'a> for ClippyCompilerCalls {
     fn early_callback(&mut self,
                       matches: &getopts::Matches,
                       sopts: &config::Options,
-                      descriptions: &diagnostics::registry::Registry,
+                      descriptions: &rustc_errors::registry::Registry,
                       output: ErrorOutputType)
                       -> Compilation {
         self.0.early_callback(matches, sopts, descriptions, output)
@@ -46,7 +46,7 @@ impl<'a> CompilerCalls<'a> for ClippyCompilerCalls {
                 sopts: &config::Options,
                 odir: &Option<PathBuf>,
                 ofile: &Option<PathBuf>,
-                descriptions: &diagnostics::registry::Registry)
+                descriptions: &rustc_errors::registry::Registry)
                 -> Option<(Input, Option<PathBuf>)> {
         self.0.no_input(matches, sopts, odir, ofile, descriptions)
     }
diff --git a/tests/compile-fail/collapsible_if.rs b/tests/compile-fail/collapsible_if.rs
@@ -139,4 +139,9 @@ fn main() {
             println!("world!")
         }
     }
+
+    if true {
+    } else {
+        assert!(true); // assert! is just an `if`
+    }
 }
diff --git a/tests/compile-fail/formatting.rs b/tests/compile-fail/formatting.rs
@@ -16,7 +16,9 @@ fn main() {
     //~| NOTE add the missing `else` or
     }
 
-    let _ = {
+    let _ = { // if as the last expression
+        let _ = 0;
+
         if foo() {
         } if foo() {
         //~^ ERROR this looks like an `else if` but the `else` is missing
@@ -26,6 +28,18 @@ fn main() {
         }
     };
 
+    let _ = { // if in the middle of a block
+        if foo() {
+        } if foo() {
+        //~^ ERROR this looks like an `else if` but the `else` is missing
+        //~| NOTE add the missing `else` or
+        }
+        else {
+        }
+
+        let _ = 0;
+    };
+
     if foo() {
     } else
     //~^ ERROR this is an `else if` but the formatting might hide it
diff --git a/tests/compile-fail/item_after_statement.rs b/tests/compile-fail/item_after_statement.rs
@@ -2,6 +2,16 @@
 #![plugin(clippy)]
 #![deny(items_after_statements)]
 
+fn ok() {
+    fn foo() { println!("foo"); }
+    foo();
+}
+
+fn last() {
+    foo();
+    fn foo() { println!("foo"); } //~ ERROR adding items after statements is confusing
+}
+
 fn main() {
     foo();
     fn foo() { println!("foo"); } //~ ERROR adding items after statements is confusing
diff --git a/tests/compile-fail/needless_bool.rs b/tests/compile-fail/needless_bool.rs
diff --git a/tests/consts.rs b/tests/consts.rs

Original file line number	Diff line number	Diff line change
`@@ -59,21 +59,13 @@ impl EarlyLintPass for Formatting {`
`59`	`59`	`fn check_block(&mut self, cx: &EarlyContext, block: &ast::Block) {`
`60`	`60`	`for w in block.stmts.windows(2) {`
`61`	`61`	`match (&w[0].node, &w[1].node) {`
`62`		`- (&ast::StmtKind::Expr(ref first, _), &ast::StmtKind::Expr(ref second, _)) \|`
`63`		`- (&ast::StmtKind::Expr(ref first, _), &ast::StmtKind::Semi(ref second, _)) => {`
	`62`	`+ (&ast::StmtKind::Expr(ref first), &ast::StmtKind::Expr(ref second)) \|`
	`63`	`+ (&ast::StmtKind::Expr(ref first), &ast::StmtKind::Semi(ref second)) => {`
`64`	`64`	`check_consecutive_ifs(cx, first, second);`
`65`	`65`	`}`
`66`	`66`	`_ => (),`
`67`	`67`	`}`
`68`	`68`	`}`
`69`		`-`
`70`		`- if let Some(ref expr) = block.expr {`
`71`		`- if let Some(ref stmt) = block.stmts.iter().last() {`
`72`		`- if let ast::StmtKind::Expr(ref first, _) = stmt.node {`
`73`		`- check_consecutive_ifs(cx, first, expr);`
`74`		`- }`
`75`		`- }`
`76`		`- }`
`77`	`69`	`}`
`78`	`70`
`79`	`71`	`fn check_expr(&mut self, cx: &EarlyContext, expr: &ast::Expr) {`
Original file line number	Diff line number	Diff line change
`@@ -68,8 +68,8 @@ const WHITELIST: &'static [&'static [&'static str]] = &[`
`68`	`68`
`69`	`69`	`struct SimilarNamesNameVisitor<'a, 'b: 'a, 'c: 'b>(&'a mut SimilarNamesLocalVisitor<'b, 'c>);`
`70`	`70`
`71`		`-impl<'v, 'a, 'b, 'c> Visitor<'v> for SimilarNamesNameVisitor<'a, 'b, 'c> {`
`72`		`- fn visit_pat(&mut self, pat: &'v Pat) {`
	`71`	`+impl<'a, 'b, 'c> Visitor for SimilarNamesNameVisitor<'a, 'b, 'c> {`
	`72`	`+ fn visit_pat(&mut self, pat: &Pat) {`
`73`	`73`	`match pat.node {`
`74`	`74`	`PatKind::Ident(_, id, _) => self.check_name(id.span, id.node.name),`
`75`	`75`	`PatKind::Struct(_, ref fields, _) => {`
`@@ -226,25 +226,25 @@ impl<'a, 'b> SimilarNamesLocalVisitor<'a, 'b> {`
`226`	`226`	`}`
`227`	`227`	`}`
`228`	`228`
`229`		`-impl<'v, 'a, 'b> Visitor<'v> for SimilarNamesLocalVisitor<'a, 'b> {`
`230`		`- fn visit_local(&mut self, local: &'v Local) {`
	`229`	`+impl<'a, 'b> Visitor for SimilarNamesLocalVisitor<'a, 'b> {`
	`230`	`+ fn visit_local(&mut self, local: &Local) {`
`231`	`231`	`if let Some(ref init) = local.init {`
`232`	`232`	`self.apply(\|this\| walk_expr(this, &**init));`
`233`	`233`	`}`
`234`	`234`	`// add the pattern after the expression because the bindings aren't available yet in the init expression`
`235`	`235`	`SimilarNamesNameVisitor(self).visit_pat(&*local.pat);`
`236`	`236`	`}`
`237`		`- fn visit_block(&mut self, blk: &'v Block) {`
	`237`	`+ fn visit_block(&mut self, blk: &Block) {`
`238`	`238`	`self.apply(\|this\| walk_block(this, blk));`
`239`	`239`	`}`
`240`		`- fn visit_arm(&mut self, arm: &'v Arm) {`
	`240`	`+ fn visit_arm(&mut self, arm: &Arm) {`
`241`	`241`	`self.apply(\|this\| {`
`242`	`242`	`// just go through the first pattern, as either all patterns bind the same bindings or rustc would have errored much earlier`
`243`	`243`	`SimilarNamesNameVisitor(this).visit_pat(&arm.pats[0]);`
`244`	`244`	`this.apply(\|this\| walk_expr(this, &arm.body));`
`245`	`245`	`});`
`246`	`246`	`}`
`247`		`- fn visit_item(&mut self, _: &'v Item) {`
	`247`	`+ fn visit_item(&mut self, _: &Item) {`
`248`	`248`	`// do not recurse into inner items`
`249`	`249`	`}`
`250`	`250`	`}`