add derivable impls lint

Author: HKalbasi

CHANGELOG.md

@@ -2483,6 +2483,7 @@ Released 2018-09-13
 [`deprecated_cfg_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr
 [`deprecated_semver`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_semver
 [`deref_addrof`]: https://rust-lang.github.io/rust-clippy/master/index.html#deref_addrof
+[`derivable_impls`]: https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
 [`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method

clippy_lints/src/derivable_impls.rs

@@ -0,0 +1,125 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{is_automatically_derived, match_def_path, paths};
+use rustc_ast::LitKind;
+use rustc_hir::{Block, BlockCheckMode, BodyId, Expr, ExprField, ExprKind, FnDecl, HirId, Impl, ImplItemKind, Item, ItemKind, Node, QPath, TraitRef, TyKind, UnsafeSource, Unsafety};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for double comparisons that could be simplified to a single expression.
+    ///
+    ///
+    /// ### Why is this bad?
+    /// Readability.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1;
+    /// # let y = 2;
+    /// if x == y || x < y {}
+    /// ```
+    ///
+    /// Could be written as:
+    ///
+    /// ```rust
+    /// # let x = 1;
+    /// # let y = 2;
+    /// if x <= y {}
+    /// ```
+    pub DERIVABLE_IMPLS,
+    complexity,
+    "manual implementation of a trait which is equal to a derive"
+}
+
+declare_lint_pass!(DerivableImpls => [DERIVABLE_IMPLS]);
+
+fn struct_fields<'hir>(e: &'hir Expr<'hir>) -> Option<&'hir [ExprField]> {
+    match e.kind {
+        ExprKind::Struct(_, fields, _) => Some(fields),
+        ExprKind::Block(Block { expr, .. }, _) => expr.and_then(struct_fields),
+        _ => None,
+    }
+}
+
+fn is_path_self(e: &Expr<'_>) -> bool {
+    if let ExprKind::Path(QPath::Resolved(_, p)) = e.kind {
+        if p.segments.len() != 1 {
+            return false;
+        }
+        if p.segments[0].ident.name == rustc_span::symbol::kw::SelfUpper {
+            return true;
+        }
+    }
+    false
+}
+
+fn tuple_fields<'hir>(e: &'hir Expr<'hir>) -> Option<&'hir [Expr<'hir>]> {
+    match e.kind {
+        ExprKind::Tup(fields) => Some(fields),
+        ExprKind::Call(callee, args) => if is_path_self(callee) {
+            Some(args)
+        } else {
+            None
+        },
+        ExprKind::Block(Block { expr, .. }, _) => expr.and_then(tuple_fields),
+        _ => None,
+    }
+}
+
+fn is_default(_cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    if let ExprKind::Lit(lit) = &e.kind {
+        match lit.node {
+            LitKind::Bool(x) => !x,
+            LitKind::Int(x, _) => x == 0,
+            _ => false,
+        }
+    } else {
+        false
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        if let ItemKind::Impl(Impl {
+            of_trait: Some(ref trait_ref),
+            self_ty,
+            items,
+            ..
+        }) = item.kind
+        {
+            let ty = cx.tcx.type_of(item.def_id);
+            let attrs = cx.tcx.hir().attrs(item.hir_id());
+            if is_automatically_derived(attrs) {
+                return;
+            }
+            if let Some(def_id) = trait_ref.trait_def_id() {
+                if !match_def_path(cx, def_id, &paths::DEFAULT_TRAIT) {
+                    return;
+                }
+            }
+            let impl_item_hir = items[0].id.hir_id();
+            let func_expr = match cx.tcx.hir().find(impl_item_hir) {
+                Some(Node::ImplItem(x)) => match &x.kind {
+                    ImplItemKind::Fn(_, b) => match cx.tcx.hir().find(b.hir_id) {
+                        Some(Node::Expr(e)) => e,
+                        _ => return,
+                    },
+                    _ => return,
+                },
+                _ => return,
+            };
+            let should_emit = if let Some(s) = struct_fields(func_expr) {
+                s.iter().all(|ef| is_default(cx, ef.expr))   
+            } else if let Some(s) = tuple_fields(func_expr) {
+                s.iter().all(|e| is_default(cx, e))
+            } else {
+                return;
+            };
+            if should_emit {
+                span_lint(cx, DERIVABLE_IMPLS, item.span, "derivable impl of trait Default:");
+            }
+        }
+    }
+}

clippy_lints/src/lib.rs

@@ -189,6 +189,7 @@ mod dbg_macro;
 mod default;
 mod default_numeric_fallback;
 mod dereference;
+mod derivable_impls;
 mod derive;
 mod disallowed_method;
 mod disallowed_script_idents;
@@ -587,6 +588,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         default::FIELD_REASSIGN_WITH_DEFAULT,
         default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
         dereference::EXPLICIT_DEREF_METHODS,
+        derivable_impls::DERIVABLE_IMPLS,
         derive::DERIVE_HASH_XOR_EQ,
         derive::DERIVE_ORD_XOR_PARTIAL_ORD,
         derive::EXPL_IMPL_CLONE_ON_COPY,
@@ -1200,6 +1202,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(copies::IFS_SAME_COND),
         LintId::of(copies::IF_SAME_THEN_ELSE),
         LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+        LintId::of(derivable_impls::DERIVABLE_IMPLS),
         LintId::of(derive::DERIVE_HASH_XOR_EQ),
         LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
         LintId::of(doc::MISSING_SAFETY_DOC),
@@ -1583,6 +1586,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(casts::CHAR_LIT_AS_U8),
         LintId::of(casts::UNNECESSARY_CAST),
         LintId::of(copies::BRANCHES_SHARING_CODE),
+        LintId::of(derivable_impls::DERIVABLE_IMPLS),
         LintId::of(double_comparison::DOUBLE_COMPARISONS),
         LintId::of(double_parens::DOUBLE_PARENS),
         LintId::of(duration_subsec::DURATION_SUBSEC),
@@ -1922,6 +1926,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box panic_unimplemented::PanicUnimplemented);
     store.register_late_pass(|| box strings::StringLitAsBytes);
     store.register_late_pass(|| box derive::Derive);
+    store.register_late_pass(|| box derivable_impls::DerivableImpls);
     store.register_late_pass(|| box get_last_with_len::GetLastWithLen);
     store.register_late_pass(|| box drop_forget_ref::DropForgetRef);
     store.register_late_pass(|| box empty_enum::EmptyEnum);

clippy_utils/src/paths.rs

@@ -31,6 +31,7 @@ pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
 pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
+pub const DEFAULT_TRAIT: [&str; 3] = ["core", "default", "Default"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
 /// Preferably use the diagnostic item `sym::deref_method` where possible

tests/ui/derivable_impls.rs

@@ -0,0 +1,63 @@
+#[deny(clippy::derivable_impls)]
+
+struct FooDefault {
+    a: bool,
+    b: i32,
+    c: u64,
+}
+
+struct TupleDefault(bool, i32, u64);
+
+struct FooND1 {
+    a: bool,
+}
+
+struct FooND2 {
+    a: i32,
+}
+
+struct FooNDNew {
+    a: bool,
+}
+
+impl std::default::Default for FooDefault {
+    fn default() -> Self {
+        Self {
+            a: false,
+            b: 0,
+            c: 0u64,
+        }
+    }
+}
+
+impl std::default::Default for TupleDefault {
+    fn default() -> Self {
+        Self(false, 0, 0u64)
+    }
+}
+
+impl std::default::Default for FooND1 {
+    fn default() -> Self {
+        Self { a: true }
+    }
+}
+
+impl std::default::Default for FooND2 {
+    fn default() -> Self {
+        Self { a: 5 }
+    }
+}
+
+impl FooNDNew {
+    fn new() -> Self {
+        Self { a: true }
+    }
+}
+
+impl Default for FooNDNew {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn main() {}

tests/ui/derivable_impls.stderr

@@ -0,0 +1,26 @@
+error: derivable impl of trait Default:
+  --> $DIR/derivable_impls.rs:23:1
+   |
+LL | / impl std::default::Default for FooDefault {
+LL | |     fn default() -> Self {
+LL | |         Self {
+LL | |             a: false,
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::derivable-impls` implied by `-D warnings`
+
+error: derivable impl of trait Default:
+  --> $DIR/derivable_impls.rs:33:1
+   |
+LL | / impl std::default::Default for TupleDefault {
+LL | |     fn default() -> Self {
+LL | |         Self(false, 0, 0u64)
+LL | |     }
+LL | | }
+   | |_^
+
+error: aborting due to 2 previous errors
+