submodules: Update clippy from 5a11ed7 to 8c80b65

tesuji · tesuji · commit db0d01492527 · 2019-06-24T09:42:31.000Z
diff --git a/README.md b/README.md
@@ -2,7 +2,6 @@
 
 [![Build Status](https://travis-ci.com/rust-lang/rust-clippy.svg?branch=master)](https://travis-ci.com/rust-lang/rust-clippy)
 [![Windows Build status](https://ci.appveyor.com/api/projects/status/id677xpw1dguo7iw?svg=true)](https://ci.appveyor.com/project/rust-lang-libs/rust-clippy)
-[![Current Version](https://meritbadge.herokuapp.com/clippy)](https://crates.io/crates/clippy)
 [![License: MIT/Apache-2.0](https://img.shields.io/crates/l/clippy.svg)](#license)
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
@@ -12,7 +11,7 @@ A collection of lints to catch common mistakes and improve your [Rust](https://g
 We have a bunch of lint categories to allow you to choose how much Clippy is supposed to ~~annoy~~ help you:
 
 * `clippy::all` (everything that is on by default: all the categories below except for `nursery`, `pedantic`, and `cargo`)
-* **`clippy::correctness`** (code that is just outright wrong or very very useless, causes hard errors by default)
+* `clippy::correctness` (code that is just **outright wrong** or **very very useless**, causes hard errors by default)
 * `clippy::style` (code that should be written in a more idiomatic way)
 * `clippy::complexity` (code that does something simple but in a complex way)
 * `clippy::perf` (code that can be written in a faster way)
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
@@ -84,18 +84,14 @@ impl EarlyLintPass for CollapsibleIf {
 }
 
 fn check_if(cx: &EarlyContext<'_>, expr: &ast::Expr) {
-    match expr.node {
-        ast::ExprKind::If(ref check, ref then, ref else_) => {
-            if let Some(ref else_) = *else_ {
-                check_collapsible_maybe_if_let(cx, else_);
-            } else {
-                check_collapsible_no_if_let(cx, expr, check, then);
-            }
-        },
-        ast::ExprKind::IfLet(_, _, _, Some(ref else_)) => {
+    if let ast::ExprKind::If(check, then, else_) = &expr.node {
+        if let Some(else_) = else_ {
             check_collapsible_maybe_if_let(cx, else_);
-        },
-        _ => (),
+        } else if let ast::ExprKind::Let(..) = check.node {
+            // Prevent triggering on `if let a = b { if c { .. } }`.
+        } else {
+            check_collapsible_no_if_let(cx, expr, check, then);
+        }
     }
 }
 
@@ -113,22 +109,18 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
         if !block_starts_with_comment(cx, block);
         if let Some(else_) = expr_block(block);
         if !in_macro_or_desugar(else_.span);
+        if let ast::ExprKind::If(..) = else_.node;
         then {
-            match else_.node {
-                ast::ExprKind::If(..) | ast::ExprKind::IfLet(..) => {
-                    let mut applicability = Applicability::MachineApplicable;
-                    span_lint_and_sugg(
-                        cx,
-                        COLLAPSIBLE_IF,
-                        block.span,
-                        "this `else { if .. }` block can be collapsed",
-                        "try",
-                        snippet_block_with_applicability(cx, else_.span, "..", &mut applicability).into_owned(),
-                        applicability,
-                    );
-                }
-                _ => (),
-            }
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                COLLAPSIBLE_IF,
+                block.span,
+                "this `else { if .. }` block can be collapsed",
+                "try",
+                snippet_block_with_applicability(cx, else_.span, "..", &mut applicability).into_owned(),
+                applicability,
+            );
         }
     }
 }
@@ -139,6 +131,11 @@ fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &
         if let Some(inner) = expr_block(then);
         if let ast::ExprKind::If(ref check_inner, ref content, None) = inner.node;
         then {
+            if let ast::ExprKind::Let(..) = check_inner.node {
+                // Prevent triggering on `if c { if let a = b { .. } }`.
+                return;
+            }
+
             if expr.span.ctxt() != inner.span.ctxt() {
                 return;
             }
diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
@@ -154,7 +154,7 @@ impl Constant {
 }
 
 /// Parses a `LitKind` to a `Constant`.
-pub fn lit_to_constant<'tcx>(lit: &LitKind, ty: Ty<'tcx>) -> Constant {
+pub fn lit_to_constant(lit: &LitKind, ty: Ty<'_>) -> Constant {
     use syntax::ast::*;
 
     match *lit {
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
@@ -248,9 +248,7 @@ fn is_block(expr: &ast::Expr) -> bool {
 /// Match `if` or `if let` expressions and return the `then` and `else` block.
 fn unsugar_if(expr: &ast::Expr) -> Option<(&P<ast::Block>, &Option<P<ast::Expr>>)> {
     match expr.node {
-        ast::ExprKind::If(_, ref then, ref else_) | ast::ExprKind::IfLet(_, _, ref then, ref else_) => {
-            Some((then, else_))
-        },
+        ast::ExprKind::If(_, ref then, ref else_) => Some((then, else_)),
         _ => None,
     }
 }
diff --git a/clippy_lints/src/identity_conversion.rs b/clippy_lints/src/identity_conversion.rs
@@ -50,8 +50,6 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityConversion {
                 };
                 if let ExprKind::Call(_, ref args) = e.node {
                     self.try_desugar_arm.push(args[0].hir_id);
-                } else {
-                    return;
                 }
             },
 
diff --git a/clippy_lints/src/invalid_ref.rs b/clippy_lints/src/invalid_ref.rs
@@ -51,6 +51,5 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidRef {
                 span_help_and_lint(cx, INVALID_REF, expr.span, msg, HELP);
             }
         }
-        return;
     }
 }
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
@@ -1647,7 +1647,7 @@ fn check_for_mutability(cx: &LateContext<'_, '_>, bound: &Expr) -> Option<HirId>
         then {
             let res = cx.tables.qpath_res(qpath, bound.hir_id);
             if let Res::Local(node_id) = res {
-                let node_str = cx.tcx.hir().get_by_hir_id(node_id);
+                let node_str = cx.tcx.hir().get(node_id);
                 if_chain! {
                     if let Node::Binding(pat) = node_str;
                     if let PatKind::Binding(bind_ann, ..) = pat.node;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
@@ -1424,7 +1424,7 @@ fn lint_clone_on_copy(cx: &LateContext<'_, '_>, expr: &hir::Expr, arg: &hir::Exp
                 snip = Some(("try removing the `clone` call", format!("{}", snippet)));
             } else {
                 let parent = cx.tcx.hir().get_parent_node_by_hir_id(expr.hir_id);
-                match cx.tcx.hir().get_by_hir_id(parent) {
+                match cx.tcx.hir().get(parent) {
                     hir::Node::Expr(parent) => match parent.node {
                         // &*x is a nop, &x.clone() is not
                         hir::ExprKind::AddrOf(..) |
@@ -1648,16 +1648,15 @@ fn lint_unnecessary_fold(cx: &LateContext<'_, '_>, expr: &hir::Expr, fold_args:
     );
 
     // Check if the first argument to .fold is a suitable literal
-    match fold_args[1].node {
-        hir::ExprKind::Lit(ref lit) => match lit.node {
+    if let hir::ExprKind::Lit(ref lit) = fold_args[1].node {
+        match lit.node {
             ast::LitKind::Bool(false) => check_fold_with_op(cx, fold_args, hir::BinOpKind::Or, "any", true),
             ast::LitKind::Bool(true) => check_fold_with_op(cx, fold_args, hir::BinOpKind::And, "all", true),
             ast::LitKind::Int(0, _) => check_fold_with_op(cx, fold_args, hir::BinOpKind::Add, "sum", false),
             ast::LitKind::Int(1, _) => check_fold_with_op(cx, fold_args, hir::BinOpKind::Mul, "product", false),
-            _ => return,
-        },
-        _ => return,
-    };
+            _ => (),
+        }
+    }
 }
 
 fn lint_iter_nth<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &hir::Expr, iter_args: &'tcx [hir::Expr], is_mut: bool) {
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
@@ -68,7 +68,7 @@ fn check_missing_inline_attrs(cx: &LateContext<'_, '_>, attrs: &[ast::Attribute]
     }
 }
 
-fn is_executable<'a, 'tcx>(cx: &LateContext<'a, 'tcx>) -> bool {
+fn is_executable(cx: &LateContext<'_, '_>) -> bool {
     use rustc::session::config::CrateType;
 
     cx.tcx.sess.crate_types.get().iter().any(|t: &CrateType| match t {
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
@@ -116,7 +116,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool {
 
 fn parent_node_is_if_expr<'a, 'b>(expr: &Expr, cx: &LateContext<'a, 'b>) -> bool {
     let parent_id = cx.tcx.hir().get_parent_node_by_hir_id(expr.hir_id);
-    let parent_node = cx.tcx.hir().get_by_hir_id(parent_id);
+    let parent_node = cx.tcx.hir().get(parent_id);
 
     if let rustc::hir::Node::Expr(e) = parent_node {
         if higher::if_block(&e).is_some() {
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
@@ -209,12 +209,11 @@ fn with_loop_block<F>(expr: &ast::Expr, mut func: F)
 where
     F: FnMut(&ast::Block, Option<&ast::Label>),
 {
-    match expr.node {
-        ast::ExprKind::While(_, ref loop_block, ref label)
-        | ast::ExprKind::WhileLet(_, _, ref loop_block, ref label)
-        | ast::ExprKind::ForLoop(_, _, ref loop_block, ref label)
-        | ast::ExprKind::Loop(ref loop_block, ref label) => func(loop_block, label.as_ref()),
-        _ => {},
+    if let ast::ExprKind::While(_, loop_block, label)
+    | ast::ExprKind::ForLoop(_, _, loop_block, label)
+    | ast::ExprKind::Loop(loop_block, label) = &expr.node
+    {
+        func(loop_block, label.as_ref());
     }
 }
 
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
@@ -169,7 +169,9 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
             .any(|id| id.name == ident.name)
         {
             return;
-        } else if let Some(scope) = &mut self.0.single_char_names.last_mut() {
+        }
+
+        if let Some(scope) = &mut self.0.single_char_names.last_mut() {
             scope.push(ident);
         }
     }
diff --git a/clippy_lints/src/redundant_pattern_matching.rs b/clippy_lints/src/redundant_pattern_matching.rs
@@ -95,8 +95,6 @@ fn find_sugg_for_if_let<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr,
                 );
             },
         );
-    } else {
-        return;
     }
 }
 
@@ -161,8 +159,6 @@ fn find_sugg_for_match<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, o
                 },
             );
         }
-    } else {
-        return;
     }
 }
 
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
@@ -83,6 +83,12 @@ declare_clippy_lint! {
     "needless unit expression"
 }
 
+#[derive(PartialEq, Eq, Copy, Clone)]
+enum RetReplacement {
+    Empty,
+    Unit,
+}
+
 declare_lint_pass!(Return => [NEEDLESS_RETURN, LET_AND_RETURN, UNUSED_UNIT]);
 
 impl Return {
@@ -91,21 +97,32 @@ impl Return {
         if let Some(stmt) = block.stmts.last() {
             match stmt.node {
                 ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => {
-                    self.check_final_expr(cx, expr, Some(stmt.span));
+                    self.check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
                 },
                 _ => (),
             }
         }
     }
 
     // Check a the final expression in a block if it's a return.
-    fn check_final_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr, span: Option<Span>) {
+    fn check_final_expr(
+        &mut self,
+        cx: &EarlyContext<'_>,
+        expr: &ast::Expr,
+        span: Option<Span>,
+        replacement: RetReplacement,
+    ) {
         match expr.node {
             // simple return is always "bad"
-            ast::ExprKind::Ret(Some(ref inner)) => {
+            ast::ExprKind::Ret(ref inner) => {
                 // allow `#[cfg(a)] return a; #[cfg(b)] return b;`
                 if !expr.attrs.iter().any(attr_is_cfg) {
-                    self.emit_return_lint(cx, span.expect("`else return` is not possible"), inner.span);
+                    self.emit_return_lint(
+                        cx,
+                        span.expect("`else return` is not possible"),
+                        inner.as_ref().map(|i| i.span),
+                        replacement,
+                    );
                 }
             },
             // a whole block? check it!
@@ -117,32 +134,60 @@ impl Return {
             // (except for unit type functions) so we don't match it
             ast::ExprKind::If(_, ref ifblock, Some(ref elsexpr)) => {
                 self.check_block_return(cx, ifblock);
-                self.check_final_expr(cx, elsexpr, None);
+                self.check_final_expr(cx, elsexpr, None, RetReplacement::Empty);
             },
             // a match expr, check all arms
             ast::ExprKind::Match(_, ref arms) => {
                 for arm in arms {
-                    self.check_final_expr(cx, &arm.body, Some(arm.body.span));
+                    self.check_final_expr(cx, &arm.body, Some(arm.body.span), RetReplacement::Unit);
                 }
             },
             _ => (),
         }
     }
 
-    fn emit_return_lint(&mut self, cx: &EarlyContext<'_>, ret_span: Span, inner_span: Span) {
-        if in_external_macro(cx.sess(), inner_span) || in_macro_or_desugar(inner_span) {
-            return;
+    fn emit_return_lint(
+        &mut self,
+        cx: &EarlyContext<'_>,
+        ret_span: Span,
+        inner_span: Option<Span>,
+        replacement: RetReplacement,
+    ) {
+        match inner_span {
+            Some(inner_span) => {
+                if in_external_macro(cx.sess(), inner_span) || in_macro_or_desugar(inner_span) {
+                    return;
+                }
+
+                span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded return statement", |db| {
+                    if let Some(snippet) = snippet_opt(cx, inner_span) {
+                        db.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
+                    }
+                })
+            },
+            None => match replacement {
+                RetReplacement::Empty => {
+                    span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded return statement", |db| {
+                        db.span_suggestion(
+                            ret_span,
+                            "remove `return`",
+                            String::new(),
+                            Applicability::MachineApplicable,
+                        );
+                    });
+                },
+                RetReplacement::Unit => {
+                    span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded return statement", |db| {
+                        db.span_suggestion(
+                            ret_span,
+                            "replace `return` with the unit type",
+                            "()".to_string(),
+                            Applicability::MachineApplicable,
+                        );
+                    });
+                },
+            },
         }
-        span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded return statement", |db| {
-            if let Some(snippet) = snippet_opt(cx, inner_span) {
-                db.span_suggestion(
-                    ret_span,
-                    "remove `return` as shown",
-                    snippet,
-                    Applicability::MachineApplicable,
-                );
-            }
-        });
     }
 
     // Check for "let x = EXPR; x"
@@ -195,7 +240,7 @@ impl EarlyLintPass for Return {
     fn check_fn(&mut self, cx: &EarlyContext<'_>, kind: FnKind<'_>, decl: &ast::FnDecl, span: Span, _: ast::NodeId) {
         match kind {
             FnKind::ItemFn(.., block) | FnKind::Method(.., block) => self.check_block_return(cx, block),
-            FnKind::Closure(body) => self.check_final_expr(cx, body, Some(body.span)),
+            FnKind::Closure(body) => self.check_final_expr(cx, body, Some(body.span), RetReplacement::Empty),
         }
         if_chain! {
             if let ast::FunctionRetTy::Ty(ref ty) = decl.output;
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
@@ -67,7 +67,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for SuspiciousImpl {
             // as a child node
             let mut parent_expr = cx.tcx.hir().get_parent_node_by_hir_id(expr.hir_id);
             while parent_expr != hir::CRATE_HIR_ID {
-                if let hir::Node::Expr(e) = cx.tcx.hir().get_by_hir_id(parent_expr) {
+                if let hir::Node::Expr(e) = cx.tcx.hir().get(parent_expr) {
                     match e.node {
                         hir::ExprKind::Binary(..)
                         | hir::ExprKind::Unary(hir::UnOp::UnNot, _)
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
diff --git a/tests/ui/collapsible_if.fixed b/tests/ui/collapsible_if.fixed
diff --git a/tests/ui/collapsible_if.rs b/tests/ui/collapsible_if.rs
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr

Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ impl Constant {`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	/// Parses a `LitKind` to a `Constant`.
`157`		`-pub fn lit_to_constant<'tcx>(lit: &LitKind, ty: Ty<'tcx>) -> Constant {`
	`157`	`+pub fn lit_to_constant(lit: &LitKind, ty: Ty<'_>) -> Constant {`
`158`	`158`	`use syntax::ast::*;`
`159`	`159`
`160`	`160`	`match *lit {`
Original file line number	Diff line number	Diff line change
`@@ -248,9 +248,7 @@ fn is_block(expr: &ast::Expr) -> bool {`
`248`	`248`	/// Match `if` or `if let` expressions and return the `then` and `else` block.
`249`	`249`	`fn unsugar_if(expr: &ast::Expr) -> Option<(&P<ast::Block>, &Option<P<ast::Expr>>)> {`
`250`	`250`	`match expr.node {`
`251`		`- ast::ExprKind::If(_, ref then, ref else_) \| ast::ExprKind::IfLet(_, _, ref then, ref else_) => {`
`252`		`- Some((then, else_))`
`253`		`- },`
	`251`	`+ ast::ExprKind::If(_, ref then, ref else_) => Some((then, else_)),`
`254`	`252`	`_ => None,`
`255`	`253`	`}`
`256`	`254`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,8 +50,6 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityConversion {`
`50`	`50`	`};`
`51`	`51`	`if let ExprKind::Call(_, ref args) = e.node {`
`52`	`52`	`self.try_desugar_arm.push(args[0].hir_id);`
`53`		`- } else {`
`54`		`- return;`
`55`	`53`	`}`
`56`	`54`	`},`
`57`	`55`
Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,5 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidRef {`
`51`	`51`	`span_help_and_lint(cx, INVALID_REF, expr.span, msg, HELP);`
`52`	`52`	`}`
`53`	`53`	`}`
`54`		`- return;`
`55`	`54`	`}`
`56`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ fn check_missing_inline_attrs(cx: &LateContext<'_, '_>, attrs: &[ast::Attribute]`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`		`-fn is_executable<'a, 'tcx>(cx: &LateContext<'a, 'tcx>) -> bool {`
	`71`	`+fn is_executable(cx: &LateContext<'_, '_>) -> bool {`
`72`	`72`	`use rustc::session::config::CrateType;`
`73`	`73`
`74`	`74`	`cx.tcx.sess.crate_types.get().iter().any(\|t: &CrateType\| match t {`