clippy_lints/src/derivable_impls.rs

   1 use clippy_utils::diagnostics::span_lint_and_help;
   2 use clippy_utils::{in_macro, is_automatically_derived, is_default_equivalent, remove_blocks};
   3 use rustc_hir::{
   4     def::{DefKind, Res},
   5     Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, TyKind,
   6 };
   7 use rustc_lint::{LateContext, LateLintPass};
   8 use rustc_session::{declare_lint_pass, declare_tool_lint};
   9 use rustc_span::sym;
  10
  11 declare_clippy_lint! {
  12     /// ### What it does
  13     /// Detects manual `std::default::Default` implementations that are identical to a derived implementation.
  14     ///
  15     /// ### Why is this bad?
  16     /// It is less concise.
  17     ///
  18     /// ### Example
  19     /// ```rust
  20     /// struct Foo {
  21     ///     bar: bool
  22     /// }
  23     ///
  24     /// impl std::default::Default for Foo {
  25     ///     fn default() -> Self {
  26     ///         Self {
  27     ///             bar: false
  28     ///         }
  29     ///     }
  30     /// }
  31     /// ```
  32     ///
  33     /// Could be written as:
  34     ///
  35     /// ```rust
  36     /// #[derive(Default)]
  37     /// struct Foo {
  38     ///     bar: bool
  39     /// }
  40     /// ```
  41     ///
  42     /// ### Known problems
  43     /// Derive macros [sometimes use incorrect bounds](https://github.com/rust-lang/rust/issues/26925)
  44     /// in generic types and the user defined `impl` maybe is more generalized or
  45     /// specialized than what derive will produce. This lint can't detect the manual `impl`
  46     /// has exactly equal bounds, and therefore this lint is disabled for types with
  47     /// generic parameters.
  48     ///
  49     pub DERIVABLE_IMPLS,
  50     complexity,
  51     "manual implementation of the `Default` trait which is equal to a derive"
  52 }
  53
  54 declare_lint_pass!(DerivableImpls => [DERIVABLE_IMPLS]);
  55
  56 fn is_path_self(e: &Expr<'_>) -> bool {
  57     if let ExprKind::Path(QPath::Resolved(_, p)) = e.kind {
  58         matches!(p.res, Res::SelfCtor(..) | Res::Def(DefKind::Ctor(..), _))
  59     } else {
  60         false
  61     }
  62 }
  63
  64 impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
  65     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
  66         if_chain! {
  67             if let ItemKind::Impl(Impl {
  68                 of_trait: Some(ref trait_ref),
  69                 items: [child],
  70                 self_ty,
  71                 ..
  72             }) = item.kind;
  73             if let attrs = cx.tcx.hir().attrs(item.hir_id());
  74             if !is_automatically_derived(attrs);
  75             if !in_macro(item.span);
  76             if let Some(def_id) = trait_ref.trait_def_id();
  77             if cx.tcx.is_diagnostic_item(sym::Default, def_id);
  78             if let impl_item_hir = child.id.hir_id();
  79             if let Some(Node::ImplItem(impl_item)) = cx.tcx.hir().find(impl_item_hir);
  80             if let ImplItemKind::Fn(_, b) = &impl_item.kind;
  81             if let Body { value: func_expr, .. } = cx.tcx.hir().body(*b);
  82             if let Some(adt_def) = cx.tcx.type_of(item.def_id).ty_adt_def();
  83             if !attrs.iter().any(|attr| attr.doc_str().is_some());
  84             if let child_attrs = cx.tcx.hir().attrs(impl_item_hir);
  85             if !child_attrs.iter().any(|attr| attr.doc_str().is_some());
  86             then {
  87                 if let TyKind::Path(QPath::Resolved(_, p)) = self_ty.kind {
  88                     if let Some(PathSegment { args: Some(a), .. }) = p.segments.last() {
  89                         for arg in a.args {
  90                             if !matches!(arg, GenericArg::Lifetime(_)) {
  91                                 return;
  92                             }
  93                         }
  94                     }
  95                 }
  96                 let should_emit = match remove_blocks(func_expr).kind {
  97                     ExprKind::Tup(fields) => fields.iter().all(|e| is_default_equivalent(cx, e)),
  98                     ExprKind::Call(callee, args)
  99                         if is_path_self(callee) => args.iter().all(|e| is_default_equivalent(cx, e)),
 100                     ExprKind::Struct(_, fields, _) => fields.iter().all(|ef| is_default_equivalent(cx, ef.expr)),
 101                     _ => false,
 102                 };
 103                 if should_emit {
 104                     let path_string = cx.tcx.def_path_str(adt_def.did);
 105                     span_lint_and_help(
 106                         cx,
 107                         DERIVABLE_IMPLS,
 108                         item.span,
 109                         "this `impl` can be derived",
 110                         None,
 111                         &format!("try annotating `{}` with `#[derive(Default)]`", path_string),
 112                     );
 113                 }
 114             }
 115         }
 116     }
 117 }