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.
}
}
-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);
}
/// 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;
// Only care about `impl PartialEq<Foo> for Foo`
// For `impl PartialEq<B> for A, input_types is [A, B]
- if trait_ref.input_types()[1] == ty {
+ if trait_ref.substs.type_at(1) == ty {
let mess = if peq_is_automatically_derived {
"you are implementing `Hash` explicitly but have derived `PartialEq`"
} else {
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"
);
}
/// 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(), ¶meter_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;
- }
+ },
_ => (),
}
}
}
- }
+ },
_ => (),
}
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`"); });
}
}