src/tools/clippy/clippy_lints/src/inherent_impl.rs

   1 //! lint on inherent implementations
   2
   3 use clippy_utils::diagnostics::span_lint_and_note;
   4 use clippy_utils::{in_macro, is_allowed};
   5 use rustc_data_structures::fx::FxHashMap;
   6 use rustc_hir::{def_id::LocalDefId, Crate, Item, ItemKind, Node};
   7 use rustc_lint::{LateContext, LateLintPass};
   8 use rustc_session::{declare_lint_pass, declare_tool_lint};
   9 use rustc_span::Span;
  10 use std::collections::hash_map::Entry;
  11
  12 declare_clippy_lint! {
  13     /// **What it does:** Checks for multiple inherent implementations of a struct
  14     ///
  15     /// **Why is this bad?** Splitting the implementation of a type makes the code harder to navigate.
  16     ///
  17     /// **Known problems:** None.
  18     ///
  19     /// **Example:**
  20     /// ```rust
  21     /// struct X;
  22     /// impl X {
  23     ///     fn one() {}
  24     /// }
  25     /// impl X {
  26     ///     fn other() {}
  27     /// }
  28     /// ```
  29     ///
  30     /// Could be written:
  31     ///
  32     /// ```rust
  33     /// struct X;
  34     /// impl X {
  35     ///     fn one() {}
  36     ///     fn other() {}
  37     /// }
  38     /// ```
  39     pub MULTIPLE_INHERENT_IMPL,
  40     restriction,
  41     "Multiple inherent impl that could be grouped"
  42 }
  43
  44 declare_lint_pass!(MultipleInherentImpl => [MULTIPLE_INHERENT_IMPL]);
  45
  46 impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
  47     fn check_crate_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Crate<'_>) {
  48         // Map from a type to it's first impl block. Needed to distinguish generic arguments.
  49         // e.g. `Foo<Bar>` and `Foo<Baz>`
  50         let mut type_map = FxHashMap::default();
  51         // List of spans to lint. (lint_span, first_span)
  52         let mut lint_spans = Vec::new();
  53
  54         for (_, impl_ids) in cx
  55             .tcx
  56             .crate_inherent_impls(())
  57             .inherent_impls
  58             .iter()
  59             .filter(|(&id, impls)| {
  60                 impls.len() > 1
  61                     // Check for `#[allow]` on the type definition
  62                     && !is_allowed(
  63                         cx,
  64                         MULTIPLE_INHERENT_IMPL,
  65                         cx.tcx.hir().local_def_id_to_hir_id(id),
  66                     )
  67             })
  68         {
  69             for impl_id in impl_ids.iter().map(|id| id.expect_local()) {
  70                 match type_map.entry(cx.tcx.type_of(impl_id)) {
  71                     Entry::Vacant(e) => {
  72                         // Store the id for the first impl block of this type. The span is retrieved lazily.
  73                         e.insert(IdOrSpan::Id(impl_id));
  74                     },
  75                     Entry::Occupied(mut e) => {
  76                         if let Some(span) = get_impl_span(cx, impl_id) {
  77                             let first_span = match *e.get() {
  78                                 IdOrSpan::Span(s) => s,
  79                                 IdOrSpan::Id(id) => {
  80                                     if let Some(s) = get_impl_span(cx, id) {
  81                                         // Remember the span of the first block.
  82                                         *e.get_mut() = IdOrSpan::Span(s);
  83                                         s
  84                                     } else {
  85                                         // The first impl block isn't considered by the lint. Replace it with the
  86                                         // current one.
  87                                         *e.get_mut() = IdOrSpan::Span(span);
  88                                         continue;
  89                                     }
  90                                 },
  91                             };
  92                             lint_spans.push((span, first_span));
  93                         }
  94                     },
  95                 }
  96             }
  97
  98             // Switching to the next type definition, no need to keep the current entries around.
  99             type_map.clear();
 100         }
 101
 102         // `TyCtxt::crate_inherent_impls` doesn't have a defined order. Sort the lint output first.
 103         lint_spans.sort_by_key(|x| x.0.lo());
 104         for (span, first_span) in lint_spans {
 105             span_lint_and_note(
 106                 cx,
 107                 MULTIPLE_INHERENT_IMPL,
 108                 span,
 109                 "multiple implementations of this structure",
 110                 Some(first_span),
 111                 "first implementation here",
 112             );
 113         }
 114     }
 115 }
 116
 117 /// Gets the span for the given impl block unless it's not being considered by the lint.
 118 fn get_impl_span(cx: &LateContext<'_>, id: LocalDefId) -> Option<Span> {
 119     let id = cx.tcx.hir().local_def_id_to_hir_id(id);
 120     if let Node::Item(&Item {
 121         kind: ItemKind::Impl(ref impl_item),
 122         span,
 123         ..
 124     }) = cx.tcx.hir().get(id)
 125     {
 126         (!in_macro(span) && impl_item.generics.params.is_empty() && !is_allowed(cx, MULTIPLE_INHERENT_IMPL, id))
 127             .then(|| span)
 128     } else {
 129         None
 130     }
 131 }
 132
 133 enum IdOrSpan {
 134     Id(LocalDefId),
 135     Span(Span),
 136 }