Update for rustc 1.19.0-nightly (4bf5c99af 2017-06-10).

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

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index a5f3b1c12f6c3ef5df04980c316640ad70958611..d8e2f0872630bf20aae3814703826118a7eb0be6 100644 (file)
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,12 +1,10 @@
 use rustc::lint::*;
-use rustc::ty::subst::Subst;
 use rustc::ty::TypeVariants;
 use rustc::ty;
 use rustc::hir::*;
-use syntax::ast::{Attribute, MetaItemKind};
 use syntax::codemap::Span;
 use utils::paths;
-use utils::{match_path, span_lint_and_then};
+use utils::{is_automatically_derived, span_lint_and_then, match_path_old, is_copy};
 
 /// **What it does:** Checks for deriving `Hash` but implementing `PartialEq`
 /// explicitly.
@@ -71,11 +69,11 @@ fn get_lints(&self) -> LintArray {
     }
 }
 
-impl LateLintPass for Derive {
-    fn check_item(&mut self, cx: &LateContext, item: &Item) {
-        if let ItemImpl(_, _, _, Some(ref trait_ref), _, _) = item.node {
-            let ty = cx.tcx.lookup_item_type(cx.tcx.map.local_def_id(item.id)).ty;
-            let is_automatically_derived = item.attrs.iter().any(is_automatically_derived);
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Derive {
+    fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
+        if let ItemImpl(_, _, _, _, Some(ref trait_ref), _, _) = item.node {
+            let ty = cx.tcx.type_of(cx.tcx.hir.local_def_id(item.id));
+            let is_automatically_derived = is_automatically_derived(&*item.attrs);
 
             check_hash_peq(cx, item.span, trait_ref, ty, is_automatically_derived);
 
@@ -87,17 +85,22 @@ fn check_item(&mut self, cx: &LateContext, item: &Item) {
 }
 
 /// Implementation of the `DERIVE_HASH_XOR_EQ` lint.
-fn check_hash_peq<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, span: Span, trait_ref: &TraitRef, ty: ty::Ty<'tcx>,
-                                hash_is_automatically_derived: bool) {
+fn check_hash_peq<'a, 'tcx>(
+    cx: &LateContext<'a, 'tcx>,
+    span: Span,
+    trait_ref: &TraitRef,
+    ty: ty::Ty<'tcx>,
+    hash_is_automatically_derived: bool
+) {
     if_let_chain! {[
-        match_path(&trait_ref.path, &paths::HASH),
+        match_path_old(&trait_ref.path, &paths::HASH),
         let Some(peq_trait_def_id) = cx.tcx.lang_items.eq_trait()
     ], {
-        let peq_trait_def = cx.tcx.lookup_trait_def(peq_trait_def_id);
+        let peq_trait_def = cx.tcx.trait_def(peq_trait_def_id);
 
         // Look for the PartialEq implementations for `ty`
         peq_trait_def.for_each_relevant_impl(cx.tcx, ty, |impl_id| {
-            let peq_is_automatically_derived = cx.tcx.get_attrs(impl_id).iter().any(is_automatically_derived);
+            let peq_is_automatically_derived = is_automatically_derived(&cx.tcx.get_attrs(impl_id));
 
             if peq_is_automatically_derived == hash_is_automatically_derived {
                 return;
@@ -118,9 +121,9 @@ fn check_hash_peq<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, span: Span, trait_re
                     cx, DERIVE_HASH_XOR_EQ, span,
                     mess,
                     |db| {
-                    if let Some(node_id) = cx.tcx.map.as_local_node_id(impl_id) {
+                    if let Some(node_id) = cx.tcx.hir.as_local_node_id(impl_id) {
                         db.span_note(
-                            cx.tcx.map.span(node_id),
+                            cx.tcx.hir.span(node_id),
                             "`PartialEq` implemented here"
                         );
                     }
@@ -132,35 +135,33 @@ fn check_hash_peq<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, span: Span, trait_re
 
 /// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
 fn check_copy_clone<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, item: &Item, trait_ref: &TraitRef, ty: ty::Ty<'tcx>) {
-    if match_path(&trait_ref.path, &paths::CLONE_TRAIT) {
-        let parameter_environment = ty::ParameterEnvironment::for_item(cx.tcx, item.id);
-        let subst_ty = ty.subst(cx.tcx, parameter_environment.free_substs);
-
-        if subst_ty.moves_by_default(cx.tcx.global_tcx(), &parameter_environment, item.span) {
-            return; // ty is not Copy
+    if match_path_old(&trait_ref.path, &paths::CLONE_TRAIT) {
+        if !is_copy(cx, ty) {
+            return;
         }
 
-        // Some types are not Clone by default but could be cloned `by hand` if necessary
         match ty.sty {
-            TypeVariants::TyEnum(def, substs) |
-            TypeVariants::TyStruct(def, substs) => {
+            TypeVariants::TyAdt(def, _) if def.is_union() => return,
+
+            // Some types are not Clone by default but could be cloned “by hand” if necessary
+            TypeVariants::TyAdt(def, substs) => {
                 for variant in &def.variants {
                     for field in &variant.fields {
                         match field.ty(cx.tcx, substs).sty {
                             TypeVariants::TyArray(_, size) if size > 32 => {
                                 return;
-                            }
+                            },
                             TypeVariants::TyFnPtr(..) => {
                                 return;
-                            }
-                            TypeVariants::TyTuple(tys) if tys.len() > 12 => {
+                            },
+                            TypeVariants::TyTuple(tys, _) if tys.len() > 12 => {
                                 return;
-                            }
+                            },
                             _ => (),
                         }
                     }
                 }
-            }
+            },
             _ => (),
         }
 
@@ -168,17 +169,6 @@ fn check_copy_clone<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, item: &Item, trait_ref
                            EXPL_IMPL_CLONE_ON_COPY,
                            item.span,
                            "you are implementing `Clone` explicitly on a `Copy` type",
-                           |db| {
-                               db.span_note(item.span, "consider deriving `Clone` or removing `Copy`");
-                           });
-    }
-}
-
-/// Checks for the `#[automatically_derived]` attribute all `#[derive]`d implementations have.
-fn is_automatically_derived(attr: &Attribute) -> bool {
-    if let MetaItemKind::Word(ref word) = attr.node.value.node {
-        word == &"automatically_derived"
-    } else {
-        false
+                           |db| { db.span_note(item.span, "consider deriving `Clone` or removing `Copy`"); });
     }
 }