uplift trait_duplication_in_bounds from clippy to rustc

Author: ibraheemdev

compiler/rustc_lint/src/builtin.rs

@@ -3140,3 +3140,101 @@ impl<'tcx> LateLintPass<'tcx> for DerefNullPtr {
         }
     }
 }
+
+declare_lint! {
+    /// ### what it does
+    /// checks for cases where generics are being used and multiple
+    /// syntax specifications for trait bounds are used simultaneously.
+    ///
+    /// ### why is this bad?
+    /// duplicate bounds makes the code
+    /// less readable than specifing them only once.
+    ///
+    /// ### example
+    /// ```rust
+    /// fn func<t: clone + default>(arg: t) where t: clone + default {}
+    /// ```
+    ///
+    /// could be written as:
+    ///
+    /// ```rust
+    /// fn func<T: Clone + Default>(arg: T) {}
+    /// ```
+    /// or
+    ///
+    /// ```rust
+    /// fn func<T>(arg: T) where T: Clone + Default {}
+    /// ```
+    pub TRAIT_DUPLICATION_IN_BOUNDS,
+    Warn,
+    "Check if the same trait bounds are specified twice during a function declaration"
+}
+
+declare_lint_pass!(TraitDuplicationInBounds => [TRAIT_DUPLICATION_IN_BOUNDS]);
+
+impl<'tcx> LateLintPass<'tcx> for TraitDuplicationInBounds {
+    fn check_generics(&mut self, cx: &LateContext<'tcx>, gen: &'tcx hir::Generics<'_>) {
+        fn get_trait_res_span_from_bound(bound: &hir::GenericBound<'_>) -> Option<(Res, Span)> {
+            if let hir::GenericBound::Trait(t, _) = bound {
+                Some((t.trait_ref.path.res, t.span))
+            } else {
+                None
+            }
+        }
+        if gen.span.from_expansion()
+            || gen.params.is_empty()
+            || gen.where_clause.predicates.is_empty()
+        {
+            return;
+        }
+
+        let mut map = FxHashMap::default();
+        for param in gen.params {
+            if let hir::ParamName::Plain(ref ident) = param.name {
+                let res = param
+                    .bounds
+                    .iter()
+                    .filter_map(get_trait_res_span_from_bound)
+                    .collect::<Vec<_>>();
+                map.insert(*ident, res);
+            }
+        }
+
+        for predicate in gen.where_clause.predicates {
+            if let hir::WherePredicate::BoundPredicate(ref bound_predicate) = predicate {
+                if !bound_predicate.span.from_expansion() {
+                    if let hir::TyKind::Path(hir::QPath::Resolved(_, hir::Path { segments, .. })) =
+                        bound_predicate.bounded_ty.kind
+                    {
+                        if let Some(segment) = segments.first() {
+                            if let Some(trait_resolutions_direct) = map.get(&segment.ident) {
+                                for (res_where, _) in bound_predicate
+                                    .bounds
+                                    .iter()
+                                    .filter_map(get_trait_res_span_from_bound)
+                                {
+                                    if let Some((_, span_direct)) = trait_resolutions_direct
+                                        .iter()
+                                        .find(|(res_direct, _)| *res_direct == res_where)
+                                    {
+                                        cx.struct_span_lint(
+                                            TRAIT_DUPLICATION_IN_BOUNDS,
+                                            *span_direct,
+                                            |lint| {
+                                                lint.build(
+                                                "this trait bound is already specified in the where clause"
+                                                )
+                                                .help("consider removing this trait bound")
+                                                .emit()
+                                            },
+                                        );
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

compiler/rustc_lint/src/lib.rs

@@ -197,6 +197,7 @@ macro_rules! late_lint_mod_passes {
                 // Depends on referenced function signatures in expressions
                 MutableTransmutes: MutableTransmutes,
                 TypeAliasBounds: TypeAliasBounds,
+                TraitDuplicationInBounds: TraitDuplicationInBounds,
                 TrivialConstraints: TrivialConstraints,
                 TypeLimits: TypeLimits::new(),
                 NonSnakeCase: NonSnakeCase,

src/tools/clippy/tests/ui/trait_duplication_in_bounds.rs renamed to src/test/ui/lint/trait_duplication_in_bounds.rs

@@ -1,8 +1,10 @@
-#![deny(clippy::trait_duplication_in_bounds)]
+#![deny(trait_duplication_in_bounds)]
 
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
 fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
+//~^ ERROR this trait bound is already specified in the where clause
+//~| ERROR this trait bound is already specified in the where clause
 where
     T: Clone,
     T: Default,

src/tools/clippy/tests/ui/trait_duplication_in_bounds.stderr renamed to src/test/ui/lint/trait_duplication_in_bounds.stderr

@@ -7,8 +7,8 @@ LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
 note: the lint level is defined here
   --> $DIR/trait_duplication_in_bounds.rs:1:9
    |
-LL | #![deny(clippy::trait_duplication_in_bounds)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(trait_duplication_in_bounds)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in the where clause

src/tools/clippy/clippy_lints/src/lib.rs

@@ -925,7 +925,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         temporary_assignment::TEMPORARY_ASSIGNMENT,
         to_digit_is_some::TO_DIGIT_IS_SOME,
         to_string_in_display::TO_STRING_IN_DISPLAY,
-        trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
         trait_bounds::TYPE_REPETITION_IN_BOUNDS,
         transmute::CROSSPOINTER_TRANSMUTE,
         transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
@@ -1133,7 +1132,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
         LintId::of(shadow::SHADOW_UNRELATED),
         LintId::of(strings::STRING_ADD_ASSIGN),
-        LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
         LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
         LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
         LintId::of(types::LINKEDLIST),

src/tools/clippy/clippy_lints/src/trait_bounds.rs

@@ -2,13 +2,11 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::{in_macro, SpanlessHash};
 use if_chain::if_chain;
-use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
-use rustc_hir::{def::Res, GenericBound, Generics, ParamName, Path, QPath, TyKind, WherePredicate};
+use rustc_hir::{GenericBound, Generics, WherePredicate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -33,35 +31,6 @@ declare_clippy_lint! {
     "Types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for cases where generics are being used and multiple
-    /// syntax specifications for trait bounds are used simultaneously.
-    ///
-    /// ### Why is this bad?
-    /// Duplicate bounds makes the code
-    /// less readable than specifing them only once.
-    ///
-    /// ### Example
-    /// ```rust
-    /// fn func<T: Clone + Default>(arg: T) where T: Clone + Default {}
-    /// ```
-    ///
-    /// Could be written as:
-    ///
-    /// ```rust
-    /// fn func<T: Clone + Default>(arg: T) {}
-    /// ```
-    /// or
-    ///
-    /// ```rust
-    /// fn func<T>(arg: T) where T: Clone + Default {}
-    /// ```
-    pub TRAIT_DUPLICATION_IN_BOUNDS,
-    pedantic,
-    "Check if the same trait bounds are specified twice during a function declaration"
-}
-
 #[derive(Copy, Clone)]
 pub struct TraitBounds {
     max_trait_bounds: u64,
@@ -74,20 +43,11 @@ impl TraitBounds {
     }
 }
 
-impl_lint_pass!(TraitBounds => [TYPE_REPETITION_IN_BOUNDS, TRAIT_DUPLICATION_IN_BOUNDS]);
+impl_lint_pass!(TraitBounds => [TYPE_REPETITION_IN_BOUNDS]);
 
 impl<'tcx> LateLintPass<'tcx> for TraitBounds {
     fn check_generics(&mut self, cx: &LateContext<'tcx>, gen: &'tcx Generics<'_>) {
         self.check_type_repetition(cx, gen);
-        check_trait_bound_duplication(cx, gen);
-    }
-}
-
-fn get_trait_res_span_from_bound(bound: &GenericBound<'_>) -> Option<(Res, Span)> {
-    if let GenericBound::Trait(t, _) = bound {
-        Some((t.trait_ref.path.res, t.span))
-    } else {
-        None
     }
 }
 
@@ -149,47 +109,3 @@ impl TraitBounds {
         }
     }
 }
-
-fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
-    if in_macro(gen.span) || gen.params.is_empty() || gen.where_clause.predicates.is_empty() {
-        return;
-    }
-
-    let mut map = FxHashMap::default();
-    for param in gen.params {
-        if let ParamName::Plain(ref ident) = param.name {
-            let res = param
-                .bounds
-                .iter()
-                .filter_map(get_trait_res_span_from_bound)
-                .collect::<Vec<_>>();
-            map.insert(*ident, res);
-        }
-    }
-
-    for predicate in gen.where_clause.predicates {
-        if_chain! {
-            if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate;
-            if !in_macro(bound_predicate.span);
-            if let TyKind::Path(QPath::Resolved(_, Path { segments, .. })) = bound_predicate.bounded_ty.kind;
-            if let Some(segment) = segments.first();
-            if let Some(trait_resolutions_direct) = map.get(&segment.ident);
-            then {
-                for (res_where, _) in bound_predicate.bounds.iter().filter_map(get_trait_res_span_from_bound) {
-                    if let Some((_, span_direct)) = trait_resolutions_direct
-                                                .iter()
-                                                .find(|(res_direct, _)| *res_direct == res_where) {
-                        span_lint_and_help(
-                            cx,
-                            TRAIT_DUPLICATION_IN_BOUNDS,
-                            *span_direct,
-                            "this trait bound is already specified in the where clause",
-                            None,
-                            "consider removing this trait bound",
-                        );
-                    }
-                }
-            }
-        }
-    }
-}