Merge branch 'macro-use' into HEAD

[rust.git] / clippy_lints / src / needless_pass_by_value.rs

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 907f9cb85feff1b078267edfd187e04d15898c43..7463ea2d9c3db8282add6b6b5287d60633392c3b 100644 (file)
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -1,7 +1,10 @@
+use matches::matches;
 use rustc::hir::*;
 use rustc::hir::map::*;
 use rustc::hir::intravisit::FnKind;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
+use if_chain::if_chain;
 use rustc::ty::{self, RegionKind, TypeFoldable};
 use rustc::traits;
 use rustc::middle::expr_use_visitor as euv;
@@ -10,9 +13,9 @@
 use syntax::ast::NodeId;
 use syntax_pos::Span;
 use syntax::errors::DiagnosticBuilder;
-use utils::{get_trait_def_id, implements_trait, in_macro, is_copy, is_self, match_type, multispan_sugg, paths,
+use crate::utils::{get_trait_def_id, implements_trait, in_macro, is_copy, is_self, match_type, multispan_sugg, paths,
             snippet, snippet_opt, span_lint_and_then};
-use utils::ptr::get_spans;
+use crate::utils::ptr::get_spans;
 use std::collections::{HashMap, HashSet};
 use std::borrow::Cow;
 
@@ -72,8 +75,8 @@ fn check_fn(
         }
 
         match kind {
-            FnKind::ItemFn(.., abi, _, attrs) => {
-                if abi != Abi::Rust {
+            FnKind::ItemFn(.., header, _, attrs) => {
+                if header.abi != Abi::Rust {
                     return;
                 }
                 for a in attrs {
@@ -88,8 +91,8 @@ fn check_fn(
 
         // Exclude non-inherent impls
         if let Some(NodeItem(item)) = cx.tcx.hir.find(cx.tcx.hir.get_parent_node(node_id)) {
-            if matches!(item.node, ItemImpl(_, _, _, _, Some(_), _, _) |
-                ItemTrait(..))
+            if matches!(item.node, ItemKind::Impl(_, _, _, _, Some(_), _, _) |
+                ItemKind::Trait(..))
             {
                 return;
             }
@@ -152,8 +155,8 @@ fn check_fn(
 
             // Ignore `self`s.
             if idx == 0 {
-                if let PatKind::Binding(_, _, name, ..) = arg.pat.node {
-                    if name.node.as_str() == "self" {
+                if let PatKind::Binding(_, _, ident, ..) = arg.pat.node {
+                    if ident.as_str() == "self" {
                         continue;
                     }
                 }
@@ -215,11 +218,14 @@ fn check_fn(
                             if match_type(cx, ty, &paths::VEC);
                             if let Some(clone_spans) =
                                 get_spans(cx, Some(body.id()), idx, &[("clone", ".to_owned()")]);
-                            if let TyPath(QPath::Resolved(_, ref path)) = input.node;
+                            if let TyKind::Path(QPath::Resolved(_, ref path)) = input.node;
                             if let Some(elem_ty) = path.segments.iter()
-                                .find(|seg| seg.name == "Vec")
-                                .and_then(|ps| ps.parameters.as_ref())
-                                .map(|params| &params.types[0]);
+                                .find(|seg| seg.ident.name == "Vec")
+                                .and_then(|ps| ps.args.as_ref())
+                                .map(|params| params.args.iter().find_map(|arg| match arg {
+                                    GenericArg::Type(ty) => Some(ty),
+                                    GenericArg::Lifetime(_) => None,
+                                }).unwrap());
                             then {
                                 let slice_ty = format!("&[{}]", snippet(cx, elem_ty.span, "_"));
                                 db.span_suggestion(input.span,
@@ -336,7 +342,7 @@ fn non_moving_pat(&mut self, matched_pat: &Pat, cmt: &mc::cmt_<'tcx>) {
                     match node {
                         map::Node::NodeExpr(e) => {
                             // `match` and `if let`
-                            if let ExprMatch(ref c, ..) = e.node {
+                            if let ExprKind::Match(ref c, ..) = e.node {
                                 self.spans_need_deref
                                     .entry(vid)
                                     .or_insert_with(HashSet::new)
@@ -347,8 +353,8 @@ fn non_moving_pat(&mut self, matched_pat: &Pat, cmt: &mc::cmt_<'tcx>) {
                         map::Node::NodeStmt(s) => {
                             // `let <pat> = x;`
                             if_chain! {
-                                if let StmtDecl(ref decl, _) = s.node;
-                                if let DeclLocal(ref local) = decl.node;
+                                if let StmtKind::Decl(ref decl, _) = s.node;
+                                if let DeclKind::Local(ref local) = decl.node;
                                 then {
                                     self.spans_need_deref
                                         .entry(vid)