use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
+use if_chain::if_chain;
use rustc::ty::{self, Ty};
use rustc::hir::*;
use syntax::codemap::Span;
-use utils::paths;
-use utils::{is_automatically_derived, span_lint_and_then, match_path_old, is_copy};
+use crate::utils::paths;
+use crate::utils::{is_automatically_derived, is_copy, match_path, span_lint_and_then};
/// **What it does:** Checks for deriving `Hash` but implementing `PartialEq`
-/// explicitly.
+/// explicitly or vice versa.
///
/// **Why is this bad?** The implementation of these traits must agree (for
/// example for use with `HashMap`) so it’s probably a bad idea to use a
/// ...
/// }
/// ```
-declare_lint! {
+declare_clippy_lint! {
pub DERIVE_HASH_XOR_EQ,
- Warn,
+ correctness,
"deriving `Hash` but implementing `PartialEq` explicitly"
}
/// nothing more than copy the object, which is what `#[derive(Copy, Clone)]`
/// gets you.
///
-/// **Known problems:** None.
+/// **Known problems:** Bounds of generic types are sometimes wrong: https://github.com/rust-lang/rust/issues/26925
///
/// **Example:**
/// ```rust
/// ..
/// }
/// ```
-declare_lint! {
+declare_clippy_lint! {
pub EXPL_IMPL_CLONE_ON_COPY,
- Warn,
+ pedantic,
"implementing `Clone` explicitly on `Copy` types"
}
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 {
+ if let ItemKind::Impl(_, _, _, _, 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);
span: Span,
trait_ref: &TraitRef,
ty: Ty<'tcx>,
- hash_is_automatically_derived: bool
+ hash_is_automatically_derived: bool,
) {
- if_let_chain! {[
- match_path_old(&trait_ref.path, &paths::HASH),
- let Some(peq_trait_def_id) = cx.tcx.lang_items.eq_trait()
- ], {
- // Look for the PartialEq implementations for `ty`
- cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
- let peq_is_automatically_derived = is_automatically_derived(&cx.tcx.get_attrs(impl_id));
-
- if peq_is_automatically_derived == hash_is_automatically_derived {
- return;
- }
+ if_chain! {
+ if match_path(&trait_ref.path, &paths::HASH);
+ if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait();
+ then {
+ // Look for the PartialEq implementations for `ty`
+ cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
+ let peq_is_automatically_derived = is_automatically_derived(&cx.tcx.get_attrs(impl_id));
+
+ if peq_is_automatically_derived == hash_is_automatically_derived {
+ return;
+ }
- let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
-
- // Only care about `impl PartialEq<Foo> for Foo`
- // For `impl PartialEq<B> for A, input_types is [A, B]
- 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 {
- "you are deriving `Hash` but have implemented `PartialEq` explicitly"
- };
-
- span_lint_and_then(
- cx, DERIVE_HASH_XOR_EQ, span,
- mess,
- |db| {
- if let Some(node_id) = cx.tcx.hir.as_local_node_id(impl_id) {
- db.span_note(
- cx.tcx.hir.span(node_id),
- "`PartialEq` implemented here"
- );
- }
- });
- }
- });
- }}
+ let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
+
+ // Only care about `impl PartialEq<Foo> for Foo`
+ // For `impl PartialEq<B> for A, input_types is [A, B]
+ 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 {
+ "you are deriving `Hash` but have implemented `PartialEq` explicitly"
+ };
+
+ span_lint_and_then(
+ cx, DERIVE_HASH_XOR_EQ, span,
+ mess,
+ |db| {
+ if let Some(node_id) = cx.tcx.hir.as_local_node_id(impl_id) {
+ db.span_note(
+ 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<'tcx>) {
- if match_path_old(&trait_ref.path, &paths::CLONE_TRAIT) {
+ if match_path(&trait_ref.path, &paths::CLONE_TRAIT) {
if !is_copy(cx, ty) {
return;
}
ty::TyAdt(def, _) if def.is_union() => return,
// Some types are not Clone by default but could be cloned “by hand” if necessary
- ty::TyAdt(def, substs) => {
- for variant in &def.variants {
- for field in &variant.fields {
- match field.ty(cx.tcx, substs).sty {
- ty::TyArray(_, size) if size > 32 => {
- return;
- },
- ty::TyFnPtr(..) => {
- return;
- },
- ty::TyTuple(tys, _) if tys.len() > 12 => {
- return;
- },
- _ => (),
+ ty::TyAdt(def, substs) => for variant in &def.variants {
+ for field in &variant.fields {
+ if let ty::TyFnDef(..) = field.ty(cx.tcx, substs).sty {
+ return;
+ }
+ }
+ for subst in substs {
+ if let ty::subst::UnpackedKind::Type(subst) = subst.unpack() {
+ if let ty::TyParam(_) = subst.sty {
+ return;
}
}
}
_ => (),
}
- span_lint_and_then(cx,
- 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`"); });
+ span_lint_and_then(
+ cx,
+ 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`");
+ },
+ );
}
}
projects / rust.git / blobdiff