Add impl_trait_param lint

As this is a lint about "style", and a purely cosmetical choice (using `<A: Trait>` over `impl Trait`), a lot of other files needed to be allowed this lint.

Author: blyxyas

CHANGELOG.md

@@ -4430,6 +4430,7 @@ Released 2018-09-13
 [`if_same_then_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else
 [`if_then_some_else_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none
 [`ifs_same_cond`]: https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond
+[`impl_trait_param`]: https://rust-lang.github.io/rust-clippy/master/index.html#impl_trait_param
 [`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
 [`implicit_hasher`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher
 [`implicit_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_return

clippy_lints/src/declared_lints.rs

@@ -179,6 +179,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR_INFO,
     crate::from_str_radix_10::FROM_STR_RADIX_10_INFO,
     crate::functions::DOUBLE_MUST_USE_INFO,
+    crate::functions::IMPL_TRAIT_PARAM_INFO,
     crate::functions::MISNAMED_GETTERS_INFO,
     crate::functions::MUST_USE_CANDIDATE_INFO,
     crate::functions::MUST_USE_UNIT_INFO,

clippy_lints/src/functions/impl_trait_param.rs

@@ -0,0 +1,88 @@
+use clippy_utils::{diagnostics::span_lint_and_then, is_in_test_function};
+
+use rustc_hir::{intravisit::FnKind, Body, Generics, HirId};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+
+use super::IMPL_TRAIT_PARAM;
+
+pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body: &'tcx Body<'_>, hir_id: HirId) {
+    if cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public() && !is_in_test_function(cx.tcx, hir_id)
+    {
+        if let FnKind::ItemFn(ident, generics, _) = kind {
+            for param in generics.params {
+                if param.is_impl_trait()
+                    && !param.name.ident().as_str().contains('<')
+                    && !param.name.ident().as_str().contains('(')
+                {
+                    // No generics with nested generics, and no generics like FnMut(x)
+                    span_lint_and_then(
+                        cx,
+                        IMPL_TRAIT_PARAM,
+                        param.span,
+                        &format!("'{}' in the function's parameters", param.name.ident().as_str()),
+                        |diag| {
+                            let next_letter = next_valid_letter(generics);
+                            if let Some(gen_span) = generics.span_for_param_suggestion() {
+                                diag.span_suggestion_with_style(
+                                    gen_span,
+                                    format!(
+                                        "create a generic type here and replace that `{}` with `{}`",
+                                        param.name.ident().as_str(),
+                                        next_letter
+                                    ),
+                                    ", T: Trait",
+                                    rustc_errors::Applicability::MaybeIncorrect,
+                                    rustc_errors::SuggestionStyle::ShowAlways,
+                                );
+                            } else {
+                                // multispan.push_span_label(param.span, format!("Replace this with `{}`",
+                                // next_letter));
+
+                                diag.span_suggestion_with_style(
+                                    Span::new(
+                                        body.params[0].span.lo() - rustc_span::BytePos(1),
+                                        ident.span.hi(),
+                                        ident.span.ctxt(),
+                                        ident.span.parent(),
+                                    ),
+                                    format!(
+                                        "create a generic type here and replace that '{}' with `{}`",
+                                        param.name.ident().as_str(),
+                                        next_letter
+                                    ),
+                                    "<T: Trait>",
+                                    rustc_errors::Applicability::MaybeIncorrect,
+                                    rustc_errors::SuggestionStyle::ShowAlways,
+                                );
+                            }
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn next_valid_letter(generics: &Generics<'_>) -> char {
+    let mut generics_names = Vec::new();
+
+    generics.params.iter().for_each(|param| {
+        generics_names.push(param.name.ident().as_str().to_owned());
+    });
+
+    // If T exists, try with U, then with V, and so on...
+    let mut current_letter = 84u32; // ASCII code for "T"
+    while generics_names.contains(&String::from(char::from_u32(current_letter).unwrap())) {
+        current_letter += 1;
+        if current_letter == 91 {
+            // ASCII code for "Z"
+            current_letter = 65;
+        } else if current_letter == 83 {
+            // ASCII "S"
+            current_letter = 97; // "a"
+        };
+    }
+
+    char::from_u32(current_letter).unwrap()
+}

clippy_lints/src/functions/mod.rs

@@ -1,3 +1,4 @@
+mod impl_trait_param;
 mod misnamed_getters;
 mod must_use;
 mod not_unsafe_ptr_arg_deref;
@@ -327,6 +328,32 @@ declare_clippy_lint! {
     "getter method returning the wrong field"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lints when `impl Trait` is being used in a function's paremeters.
+    /// ### Why is this bad?
+    /// Turbofish syntax (`::<>`) cannot be used when `impl Trait` is being used, making `impl Trait` less powerful. Readability may also be a factor.
+    ///
+    /// ### Example
+    /// ```rust
+    /// trait MyTrait {}
+    /// fn foo(a: impl MyTrait) {
+    /// 	// [...]
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// trait MyTrait {}
+    /// fn foo<T: A>(a: A) {
+    /// 	// [...]
+    /// }
+    /// ```
+    #[clippy::version = "1.68.0"]
+    pub IMPL_TRAIT_PARAM,
+    style,
+    "`impl Trait` is used in the function's parameters"
+}
+
 #[derive(Copy, Clone)]
 pub struct Functions {
     too_many_arguments_threshold: u64,
@@ -354,6 +381,7 @@ impl_lint_pass!(Functions => [
     RESULT_UNIT_ERR,
     RESULT_LARGE_ERR,
     MISNAMED_GETTERS,
+    IMPL_TRAIT_PARAM,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Functions {
@@ -371,6 +399,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         too_many_lines::check_fn(cx, kind, span, body, self.too_many_lines_threshold);
         not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, def_id);
         misnamed_getters::check_fn(cx, kind, decl, body, span);
+        impl_trait_param::check_fn(cx, &kind, body, hir_id);
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {

clippy_utils/src/ast_utils.rs

@@ -2,7 +2,12 @@
 //!
 //! - The `eq_foobar` functions test for semantic equality but ignores `NodeId`s and `Span`s.
 
-#![allow(clippy::similar_names, clippy::wildcard_imports, clippy::enum_glob_use)]
+#![allow(
+    clippy::similar_names,
+    clippy::wildcard_imports,
+    clippy::enum_glob_use,
+    clippy::impl_trait_param
+)]
 
 use crate::{both, over};
 use rustc_ast::ptr::P;

clippy_utils/src/check_proc_macro.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::impl_trait_param)]
 //! This module handles checking if the span given is from a proc-macro or not.
 //!
 //! Proc-macros are capable of setting the span of every token they output to a few possible spans.

clippy_utils/src/hir_utils.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::impl_trait_param)]
 use crate::consts::constant_simple;
 use crate::macros::macro_backtrace;
 use crate::source::snippet_opt;

clippy_utils/src/macros.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::similar_names)] // `expr` and `expn`
+#![allow(clippy::similar_names, clippy::impl_trait_param)] // `expr` and `expn`
 
 use crate::source::snippet_opt;
 use crate::visitors::{for_each_expr, Descend};

clippy_utils/src/source.rs

@@ -1,6 +1,6 @@
 //! Utils for extracting, inspecting or transforming source code
 
-#![allow(clippy::module_name_repetitions)]
+#![allow(clippy::module_name_repetitions, clippy::impl_trait_param)]
 
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};

tests/ui/borrow_box.rs

@@ -1,6 +1,6 @@
 #![deny(clippy::borrowed_box)]
 #![allow(dead_code, unused_variables)]
-#![allow(clippy::uninlined_format_args, clippy::disallowed_names)]
+#![allow(clippy::uninlined_format_args, clippy::disallowed_names, clippy::impl_trait_param)]
 
 use std::fmt::Display;