Add some documentation and minor cleanup

Author: mkrasnitski

README.md

@@ -5,7 +5,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 550 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 600 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint level](https://doc.rust-lang.org/rustc/lints/levels.html).
 You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.

book/src/README.md

@@ -6,7 +6,7 @@
 A collection of lints to catch common mistakes and improve your
 [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 550 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 600 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint
 level](https://doc.rust-lang.org/rustc/lints/levels.html). You can choose how

clippy_lints/src/extra_unused_type_parameters.rs

@@ -4,12 +4,12 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::MultiSpan;
 use rustc_hir::intravisit::{walk_impl_item, walk_item, walk_param_bound, walk_ty, Visitor};
 use rustc_hir::{
-    GenericParamKind, Generics, ImplItem, ImplItemKind, Item, ItemKind, LifetimeParamKind, Ty, TyKind, WherePredicate,
+    GenericParamKind, Generics, ImplItem, ImplItemKind, Item, ItemKind, PredicateOrigin, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{def_id::DefId, BytePos, Span};
+use rustc_span::{def_id::DefId, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -39,44 +39,52 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(ExtraUnusedTypeParameters => [EXTRA_UNUSED_TYPE_PARAMETERS]);
 
+/// A visitor struct that walks a given function and gathers generic type parameters, plus any
+/// trait bounds those parameters have.
 struct TypeWalker<'cx, 'tcx> {
     cx: &'cx LateContext<'tcx>,
-    map: FxHashMap<DefId, Span>,
-    bound_map: FxHashMap<DefId, Span>,
+    /// Collection of all the type parameters and their spans.
+    ty_params: FxHashMap<DefId, Span>,
+    /// Collection of any (inline) trait bounds corresponding to each type parameter.
+    bounds: FxHashMap<DefId, Span>,
+    /// The entire `Generics` object of the function, useful for querying purposes.
     generics: &'tcx Generics<'tcx>,
-    some_params_used: bool,
-    has_non_ty_params: bool,
+    /// The value of this will remain `true` if *every* parameter:
+    ///   1. Is a type parameter, and
+    ///   2. Goes unused in the function.
+    /// Otherwise, if any type parameters end up being used, or if any lifetime or const-generic
+    /// parameters are present, this will be set to `false`.
+    all_params_unused: bool,
 }
 
 impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
     fn new(cx: &'cx LateContext<'tcx>, generics: &'tcx Generics<'tcx>) -> Self {
-        let mut has_non_ty_params = false;
-        let map = generics
+        let mut all_params_unused = true;
+        let ty_params = generics
             .params
             .iter()
-            .filter_map(|param| match &param.kind {
-                GenericParamKind::Type { .. } => Some((param.def_id.into(), param.span)),
-                GenericParamKind::Lifetime {
-                    kind: LifetimeParamKind::Elided,
-                } => None,
-                _ => {
-                    has_non_ty_params = true;
+            .filter_map(|param| {
+                if let GenericParamKind::Type { .. } = param.kind {
+                    Some((param.def_id.into(), param.span))
+                } else {
+                    if !param.is_elided_lifetime() {
+                        all_params_unused = false;
+                    }
                     None
-                },
+                }
             })
             .collect();
         Self {
             cx,
-            map,
+            ty_params,
+            bounds: FxHashMap::default(),
             generics,
-            has_non_ty_params,
-            bound_map: FxHashMap::default(),
-            some_params_used: false,
+            all_params_unused,
         }
     }
 
     fn emit_lint(&self) {
-        let (msg, help) = match self.map.len() {
+        let (msg, help) = match self.ty_params.len() {
             0 => return,
             1 => (
                 "type parameter goes unused in function definition",
@@ -89,27 +97,21 @@ impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
         };
 
         let source_map = self.cx.tcx.sess.source_map();
-        let span = if self.some_params_used || self.has_non_ty_params {
+        let span = if self.all_params_unused {
+            self.generics.span.into() // Remove the entire list of generics
+        } else {
             MultiSpan::from_spans(
-                self.map
+                self.ty_params
                     .iter()
-                    .map(|(def_id, &(mut span))| {
-                        if let Some(bound_span) = self.bound_map.get(def_id) {
-                            span = span.with_hi(bound_span.hi());
-                        }
-                        span = source_map.span_extend_to_next_char(span, ',', false);
-                        span = span.with_hi(BytePos(span.hi().0 + 1));
-
-                        let max_hi = self.generics.span.hi();
-                        if span.hi() >= max_hi {
-                            span = span.with_hi(BytePos(max_hi.0 - 1));
-                        }
-                        span
+                    .map(|(def_id, &span)| {
+                        // Extend the span past any trait bounds, and include the comma at the end.
+                        let span_to_extend = self.bounds.get(def_id).copied().map_or(span, Span::shrink_to_hi);
+                        let comma_range = source_map.span_extend_to_next_char(span_to_extend, '>', false);
+                        let comma_span = source_map.span_through_char(comma_range, ',');
+                        span.with_hi(comma_span.hi())
                     })
                     .collect(),
             )
-        } else {
-            self.generics.span.into()
         };
 
         span_lint_and_help(self.cx, EXTRA_UNUSED_TYPE_PARAMETERS, span, msg, None, help);
@@ -121,8 +123,8 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
 
     fn visit_ty(&mut self, t: &'tcx Ty<'tcx>) {
         if let Some((def_id, _)) = t.peel_refs().as_generic_param() {
-            if self.map.remove(&def_id).is_some() {
-                self.some_params_used = true;
+            if self.ty_params.remove(&def_id).is_some() {
+                self.all_params_unused = false;
             }
         } else if let TyKind::OpaqueDef(id, _, _) = t.kind {
             // Explicitly walk OpaqueDef. Normally `walk_ty` would do the job, but it calls
@@ -140,9 +142,9 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
             // Collect spans for bounds that appear in the list of generics (not in a where-clause)
             // for use in forming the help message
             if let Some((def_id, _)) = predicate.bounded_ty.peel_refs().as_generic_param()
-                && predicate.span < self.generics.where_clause_span
+                && let PredicateOrigin::GenericParam = predicate.origin
             {
-                self.bound_map.insert(def_id, predicate.span);
+                self.bounds.insert(def_id, predicate.span);
             }
             // Only walk the right-hand side of where-bounds
             for bound in predicate.bounds {