Change lint name to plural

CHANGELOG.md

@@ -965,7 +965,7 @@ Released 2021-09-09
   [#7407](https://github.com/rust-lang/rust-clippy/pull/7407)
 * [`redundant_allocation`]: Now additionally supports the `Arc<>` type
   [#7308](https://github.com/rust-lang/rust-clippy/pull/7308)
-* [`disallowed_name`]: Now allows disallowed names in test code
+* [`disallowed_names`]: Now allows disallowed names in test code
   [#7379](https://github.com/rust-lang/rust-clippy/pull/7379)
 * [`redundant_closure`]: Suggests `&mut` for `FnMut`
   [#7437](https://github.com/rust-lang/rust-clippy/pull/7437)
@@ -2066,7 +2066,7 @@ Released 2020-08-27
   [#5692](https://github.com/rust-lang/rust-clippy/pull/5692)
 * [`if_same_then_else`]: Don't assume multiplication is always commutative
   [#5702](https://github.com/rust-lang/rust-clippy/pull/5702)
-* [`disallowed_name`]: Remove `bar` from the default configuration
+* [`disallowed_names`]: Remove `bar` from the default configuration
   [#5712](https://github.com/rust-lang/rust-clippy/pull/5712)
 * [`redundant_pattern_matching`]: Avoid suggesting non-`const fn` calls in const contexts
   [#5724](https://github.com/rust-lang/rust-clippy/pull/5724)
@@ -3522,7 +3522,7 @@ Released 2018-09-13
 [`derive_partial_eq_without_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_partial_eq_without_eq
 [`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
 [`disallowed_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods
-[`disallowed_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_name
+[`disallowed_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names
 [`disallowed_script_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents
 [`disallowed_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_type
 [`disallowed_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types

clippy_lints/src/disallowed_names.rs

@@ -18,18 +18,18 @@ declare_clippy_lint! {
     /// let foo = 3.14;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub DISALLOWED_NAME,
+    pub DISALLOWED_NAMES,
     style,
     "usage of a disallowed/placeholder name"
 }
 
 #[derive(Clone, Debug)]
-pub struct DisallowedName {
+pub struct DisallowedNames {
     disallow: FxHashSet<String>,
     test_modules_deep: u32,
 }
 
-impl DisallowedName {
+impl DisallowedNames {
     pub fn new(disallow: FxHashSet<String>) -> Self {
         Self {
             disallow,
@@ -42,9 +42,9 @@ impl DisallowedName {
     }
 }
 
-impl_lint_pass!(DisallowedName => [DISALLOWED_NAME]);
+impl_lint_pass!(DisallowedNames => [DISALLOWED_NAMES]);
 
-impl<'tcx> LateLintPass<'tcx> for DisallowedName {
+impl<'tcx> LateLintPass<'tcx> for DisallowedNames {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if is_test_module_or_function(cx.tcx, item) {
             self.test_modules_deep = self.test_modules_deep.saturating_add(1);
@@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedName {
             if self.disallow.contains(&ident.name.to_string()) {
                 span_lint(
                     cx,
-                    DISALLOWED_NAME,
+                    DISALLOWED_NAMES,
                     ident.span,
                     &format!("use of a disallowed/placeholder name `{}`", ident.name),
                 );

clippy_lints/src/lib.register_all.rs

@@ -46,7 +46,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
     LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
-    LintId::of(disallowed_name::DISALLOWED_NAME),
+    LintId::of(disallowed_names::DISALLOWED_NAMES),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),

clippy_lints/src/lib.register_lints.rs

@@ -115,7 +115,7 @@ store.register_lints(&[
     derive::EXPL_IMPL_CLONE_ON_COPY,
     derive::UNSAFE_DERIVE_DESERIALIZE,
     disallowed_methods::DISALLOWED_METHODS,
-    disallowed_name::DISALLOWED_NAME,
+    disallowed_names::DISALLOWED_NAMES,
     disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
     disallowed_types::DISALLOWED_TYPES,
     doc::DOC_MARKDOWN,

clippy_lints/src/lib.register_style.rs

@@ -17,7 +17,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(dereference::NEEDLESS_BORROW),
     LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
-    LintId::of(disallowed_name::DISALLOWED_NAME),
+    LintId::of(disallowed_names::DISALLOWED_NAMES),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),

clippy_lints/src/lib.rs

@@ -204,7 +204,7 @@ mod dereference;
 mod derivable_impls;
 mod derive;
 mod disallowed_methods;
-mod disallowed_name;
+mod disallowed_names;
 mod disallowed_script_idents;
 mod disallowed_types;
 mod doc;
@@ -684,7 +684,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(overflow_check_conditional::OverflowCheckConditional));
     store.register_late_pass(|| Box::new(new_without_default::NewWithoutDefault::default()));
     let disallowed_names = conf.disallowed_names.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_late_pass(move || Box::new(disallowed_name::DisallowedName::new(disallowed_names.clone())));
+    store.register_late_pass(move || Box::new(disallowed_names::DisallowedNames::new(disallowed_names.clone())));
     let too_many_arguments_threshold = conf.too_many_arguments_threshold;
     let too_many_lines_threshold = conf.too_many_lines_threshold;
     store.register_late_pass(move || {

clippy_lints/src/renamed_lints.rs

@@ -5,7 +5,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions"),
     ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions"),
     ("clippy::box_vec", "clippy::box_collection"),
-    ("clippy::blacklisted_name", "clippy::disallowed_name"),
+    ("clippy::blacklisted_name", "clippy::disallowed_names"),
     ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
     ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
     ("clippy::disallowed_method", "clippy::disallowed_methods"),

clippy_lints/src/utils/conf.rs

@@ -231,7 +231,7 @@ define_Conf! {
     /// Use the Cognitive Complexity lint instead.
     #[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
     (cyclomatic_complexity_threshold: u64 = 25),
-    /// Lint: DISALLOWED_NAME.
+    /// Lint: DISALLOWED_NAMES.
     ///
     /// The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
     /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the

tests/ui-toml/disallowed_names_append/disallowed_names.rs

@@ -1,4 +1,4 @@
-#[warn(clippy::disallowed_name)]
+#[warn(clippy::disallowed_names)]
 
 fn main() {
     // `foo` is part of the default configuration

tests/ui-toml/disallowed_names_append/disallowed_names.stderr

@@ -4,7 +4,7 @@ error: use of a disallowed/placeholder name `foo`
 LL |     let foo = "bar";
    |         ^^^
    |
-   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+   = note: `-D clippy::disallowed-names` implied by `-D warnings`
 
 error: use of a disallowed/placeholder name `ducks`
   --> $DIR/disallowed_names.rs:7:9

tests/ui-toml/disallowed_names_replace/disallowed_names.rs

@@ -1,4 +1,4 @@
-#[warn(clippy::disallowed_name)]
+#[warn(clippy::disallowed_names)]
 
 fn main() {
     // `foo` is part of the default configuration

tests/ui-toml/disallowed_names_replace/disallowed_names.stderr

@@ -4,7 +4,7 @@ error: use of a disallowed/placeholder name `ducks`
 LL |     let ducks = ["quack", "quack"];
    |         ^^^^^
    |
-   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+   = note: `-D clippy::disallowed-names` implied by `-D warnings`
 
 error: aborting due to previous error
 

tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs

@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 #![allow(clippy::single_match)]
 #![allow(unused_variables)]
-#![warn(clippy::disallowed_name)]
+#![warn(clippy::disallowed_names)]
 
 fn test(toto: ()) {}
 

tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr

@@ -4,7 +4,7 @@ error: use of a disallowed/placeholder name `toto`
 LL | fn test(toto: ()) {}
    |         ^^^^
    |
-   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+   = note: `-D clippy::disallowed-names` implied by `-D warnings`
 
 error: use of a disallowed/placeholder name `toto`
   --> $DIR/conf_french_disallowed_name.rs:9:9

tests/ui/borrow_box.rs

@@ -1,5 +1,5 @@
 #![deny(clippy::borrowed_box)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
 

tests/ui/box_collection.rs

@@ -1,5 +1,10 @@
 #![warn(clippy::all)]
-#![allow(clippy::boxed_local, clippy::needless_pass_by_value, clippy::disallowed_name, unused)]
+#![allow(
+    clippy::boxed_local,
+    clippy::needless_pass_by_value,
+    clippy::disallowed_names,
+    unused
+)]
 
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 

tests/ui/box_collection.stderr

@@ -1,5 +1,5 @@
 error: you seem to be trying to use `Box<Vec<..>>`. Consider using just `Vec<..>`
-  --> $DIR/box_collection.rs:16:15
+  --> $DIR/box_collection.rs:21:15
    |
 LL | fn test1(foo: Box<Vec<bool>>) {}
    |               ^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | fn test1(foo: Box<Vec<bool>>) {}
    = help: `Vec<..>` is already on the heap, `Box<Vec<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<String>`. Consider using just `String`
-  --> $DIR/box_collection.rs:23:15
+  --> $DIR/box_collection.rs:28:15
    |
 LL | fn test3(foo: Box<String>) {}
    |               ^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL | fn test3(foo: Box<String>) {}
    = help: `String` is already on the heap, `Box<String>` makes an extra allocation
 
 error: you seem to be trying to use `Box<HashMap<..>>`. Consider using just `HashMap<..>`
-  --> $DIR/box_collection.rs:25:15
+  --> $DIR/box_collection.rs:30:15
    |
 LL | fn test4(foo: Box<HashMap<String, String>>) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL | fn test4(foo: Box<HashMap<String, String>>) {}
    = help: `HashMap<..>` is already on the heap, `Box<HashMap<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<HashSet<..>>`. Consider using just `HashSet<..>`
-  --> $DIR/box_collection.rs:27:15
+  --> $DIR/box_collection.rs:32:15
    |
 LL | fn test5(foo: Box<HashSet<i64>>) {}
    |               ^^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL | fn test5(foo: Box<HashSet<i64>>) {}
    = help: `HashSet<..>` is already on the heap, `Box<HashSet<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<VecDeque<..>>`. Consider using just `VecDeque<..>`
-  --> $DIR/box_collection.rs:29:15
+  --> $DIR/box_collection.rs:34:15
    |
 LL | fn test6(foo: Box<VecDeque<i32>>) {}
    |               ^^^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL | fn test6(foo: Box<VecDeque<i32>>) {}
    = help: `VecDeque<..>` is already on the heap, `Box<VecDeque<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<LinkedList<..>>`. Consider using just `LinkedList<..>`
-  --> $DIR/box_collection.rs:31:15
+  --> $DIR/box_collection.rs:36:15
    |
 LL | fn test7(foo: Box<LinkedList<i16>>) {}
    |               ^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL | fn test7(foo: Box<LinkedList<i16>>) {}
    = help: `LinkedList<..>` is already on the heap, `Box<LinkedList<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<BTreeMap<..>>`. Consider using just `BTreeMap<..>`
-  --> $DIR/box_collection.rs:33:15
+  --> $DIR/box_collection.rs:38:15
    |
 LL | fn test8(foo: Box<BTreeMap<i8, String>>) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL | fn test8(foo: Box<BTreeMap<i8, String>>) {}
    = help: `BTreeMap<..>` is already on the heap, `Box<BTreeMap<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<BTreeSet<..>>`. Consider using just `BTreeSet<..>`
-  --> $DIR/box_collection.rs:35:15
+  --> $DIR/box_collection.rs:40:15
    |
 LL | fn test9(foo: Box<BTreeSet<u64>>) {}
    |               ^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL | fn test9(foo: Box<BTreeSet<u64>>) {}
    = help: `BTreeSet<..>` is already on the heap, `Box<BTreeSet<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<BinaryHeap<..>>`. Consider using just `BinaryHeap<..>`
-  --> $DIR/box_collection.rs:37:16
+  --> $DIR/box_collection.rs:42:16
    |
 LL | fn test10(foo: Box<BinaryHeap<u32>>) {}
    |                ^^^^^^^^^^^^^^^^^^^^

tests/ui/crashes/ice-2760.rs

@@ -1,4 +1,9 @@
-#![allow(unused_variables, clippy::disallowed_name, clippy::needless_pass_by_value, dead_code)]
+#![allow(
+    unused_variables,
+    clippy::disallowed_names,
+    clippy::needless_pass_by_value,
+    dead_code
+)]
 
 /// This should not compile-fail with:
 ///

tests/ui/crashes/ice-3462.rs

@@ -1,5 +1,5 @@
 #![warn(clippy::all)]
-#![allow(clippy::disallowed_name, clippy::equatable_if_let)]
+#![allow(clippy::disallowed_names, clippy::equatable_if_let)]
 #![allow(unused)]
 
 /// Test for https://github.com/rust-lang/rust-clippy/issues/3462

tests/ui/crashes/regressions.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 
 pub fn foo(bar: *const u8) {
     println!("{:#p}", bar);

tests/ui/disallowed_names.rs

@@ -6,7 +6,7 @@
     unused_mut,
     unused_variables
 )]
-#![warn(clippy::disallowed_name)]
+#![warn(clippy::disallowed_names)]
 
 fn test(foo: ()) {}
 
@@ -46,7 +46,7 @@ fn issue_1647_ref_mut() {
 
 mod tests {
     fn issue_7305() {
-        // `disallowed_name` lint should not be triggered inside of the test code.
+        // `disallowed_names` lint should not be triggered inside of the test code.
         let foo = 0;
 
         // Check that even in nested functions warning is still not triggered.

tests/ui/disallowed_names.stderr

@@ -1,85 +1,85 @@
 error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_name.rs:11:9
+  --> $DIR/disallowed_names.rs:11:9
    |
 LL | fn test(foo: ()) {}
    |         ^^^
    |
-   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+   = note: `-D clippy::disallowed-names` implied by `-D warnings`
 
 error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_name.rs:14:9
+  --> $DIR/disallowed_names.rs:14:9
    |
 LL |     let foo = 42;
    |         ^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_name.rs:15:9
+  --> $DIR/disallowed_names.rs:15:9
    |
 LL |     let baz = 42;
    |         ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_name.rs:16:9
+  --> $DIR/disallowed_names.rs:16:9
    |
 LL |     let quux = 42;
    |         ^^^^
 
 error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_name.rs:27:10
+  --> $DIR/disallowed_names.rs:27:10
    |
 LL |         (foo, Some(baz), quux @ Some(_)) => (),
    |          ^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_name.rs:27:20
+  --> $DIR/disallowed_names.rs:27:20
    |
 LL |         (foo, Some(baz), quux @ Some(_)) => (),
    |                    ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_name.rs:27:26
+  --> $DIR/disallowed_names.rs:27:26
    |
 LL |         (foo, Some(baz), quux @ Some(_)) => (),
    |                          ^^^^
 
 error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_name.rs:32:19
+  --> $DIR/disallowed_names.rs:32:19
    |
 LL | fn issue_1647(mut foo: u8) {
    |                   ^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_name.rs:33:13
+  --> $DIR/disallowed_names.rs:33:13
    |
 LL |     let mut baz = 0;
    |             ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_name.rs:34:21
+  --> $DIR/disallowed_names.rs:34:21
    |
 LL |     if let Some(mut quux) = Some(42) {}
    |                     ^^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_name.rs:38:13
+  --> $DIR/disallowed_names.rs:38:13
    |
 LL |     let ref baz = 0;
    |             ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_name.rs:39:21
+  --> $DIR/disallowed_names.rs:39:21
    |
 LL |     if let Some(ref quux) = Some(42) {}
    |                     ^^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_name.rs:43:17
+  --> $DIR/disallowed_names.rs:43:17
    |
 LL |     let ref mut baz = 0;
    |                 ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_name.rs:44:25
+  --> $DIR/disallowed_names.rs:44:25
    |
 LL |     if let Some(ref mut quux) = Some(42) {}
    |                         ^^^^

tests/ui/if_same_then_else.rs

@@ -1,6 +1,6 @@
 #![warn(clippy::if_same_then_else)]
 #![allow(
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::eq_op,
     clippy::never_loop,
     clippy::no_effect,

tests/ui/if_same_then_else2.rs

@@ -1,6 +1,6 @@
 #![warn(clippy::if_same_then_else)]
 #![allow(
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::collapsible_else_if,
     clippy::equatable_if_let,
     clippy::collapsible_if,

tests/ui/iter_skip_next.fixed

@@ -2,7 +2,7 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::iter_skip_next)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::iter_nth)]
 #![allow(unused_mut, dead_code)]
 

tests/ui/iter_skip_next.rs

@@ -2,7 +2,7 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::iter_skip_next)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::iter_nth)]
 #![allow(unused_mut, dead_code)]
 

tests/ui/let_if_seq.rs

@@ -2,7 +2,7 @@
     unused_variables,
     unused_assignments,
     clippy::similar_names,
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::branches_sharing_code,
     clippy::needless_late_init
 )]

tests/ui/manual_ok_or.fixed

@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::manual_ok_or)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_closure)]
 #![allow(dead_code)]
 #![allow(unused_must_use)]

tests/ui/manual_ok_or.rs

@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::manual_ok_or)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_closure)]
 #![allow(dead_code)]
 #![allow(unused_must_use)]

tests/ui/match_same_arms2.rs

@@ -1,5 +1,5 @@
 #![warn(clippy::match_same_arms)]
-#![allow(clippy::disallowed_name, clippy::diverging_sub_expression)]
+#![allow(clippy::disallowed_names, clippy::diverging_sub_expression)]
 
 fn bar<T>(_: T) {}
 fn foo() -> bool {

tests/ui/methods.rs

@@ -2,7 +2,7 @@
 
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::default_trait_access,
     clippy::missing_docs_in_private_items,
     clippy::missing_safety_doc,

tests/ui/mismatching_type_param_order.rs

@@ -1,5 +1,5 @@
 #![warn(clippy::mismatching_type_param_order)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 
 fn main() {
     struct Foo<A, B> {

tests/ui/mixed_read_write_in_expression.rs

@@ -4,7 +4,7 @@
     unused_variables,
     clippy::no_effect,
     dead_code,
-    clippy::disallowed_name
+    clippy::disallowed_names
 )]
 fn main() {
     let mut x = 0;

tests/ui/op_ref.rs

@@ -1,4 +1,4 @@
-#![allow(unused_variables, clippy::disallowed_name)]
+#![allow(unused_variables, clippy::disallowed_names)]
 #![warn(clippy::op_ref)]
 use std::collections::HashSet;
 use std::ops::{BitAnd, Mul};

tests/ui/rc_mutex.rs

@@ -1,5 +1,5 @@
 #![warn(clippy::rc_mutex)]
-#![allow(unused, clippy::disallowed_name)]
+#![allow(unused, clippy::disallowed_names)]
 
 use std::rc::Rc;
 use std::sync::Mutex;

tests/ui/redundant_allocation.rs

@@ -1,6 +1,6 @@
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::disallowed_name, unused_variables, dead_code)]
+#![allow(clippy::disallowed_names, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
 pub struct MyStruct;

tests/ui/redundant_allocation_fixable.fixed

@@ -1,7 +1,7 @@
 // run-rustfix
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::disallowed_name, unused_variables, dead_code)]
+#![allow(clippy::disallowed_names, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
 pub struct MyStruct;

tests/ui/redundant_allocation_fixable.rs

@@ -1,7 +1,7 @@
 // run-rustfix
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::disallowed_name, unused_variables, dead_code)]
+#![allow(clippy::disallowed_names, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
 pub struct MyStruct;

tests/ui/rename.fixed

@@ -6,7 +6,7 @@
 
 #![allow(clippy::blocks_in_if_conditions)]
 #![allow(clippy::box_collection)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::disallowed_methods)]
@@ -37,7 +37,7 @@
 #![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::box_collection)]
-#![warn(clippy::disallowed_name)]
+#![warn(clippy::disallowed_names)]
 #![warn(clippy::redundant_static_lifetimes)]
 #![warn(clippy::cognitive_complexity)]
 #![warn(clippy::disallowed_methods)]

tests/ui/rename.rs

@@ -6,7 +6,7 @@
 
 #![allow(clippy::blocks_in_if_conditions)]
 #![allow(clippy::box_collection)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::disallowed_methods)]

tests/ui/rename.stderr

@@ -18,11 +18,11 @@ error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
-error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_name`
+error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
   --> $DIR/rename.rs:40:9
    |
 LL | #![warn(clippy::blacklisted_name)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_name`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
   --> $DIR/rename.rs:41:9

tests/ui/skip_while_next.rs

@@ -1,7 +1,7 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::skip_while_next)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 
 extern crate option_helpers;
 use option_helpers::IteratorFalsePositives;

tests/ui/swap.fixed

@@ -2,7 +2,7 @@
 
 #![warn(clippy::all)]
 #![allow(
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::no_effect,
     clippy::redundant_clone,
     redundant_semicolons,

tests/ui/swap.rs

@@ -2,7 +2,7 @@
 
 #![warn(clippy::all)]
 #![allow(
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::no_effect,
     clippy::redundant_clone,
     redundant_semicolons,

tests/ui/trivially_copy_pass_by_ref.rs

@@ -2,7 +2,7 @@
 // normalize-stderr-test "\(limit: \d+ byte\)" -> "(limit: N byte)"
 
 #![deny(clippy::trivially_copy_pass_by_ref)]
-#![allow(clippy::disallowed_name, clippy::redundant_field_names)]
+#![allow(clippy::disallowed_names, clippy::redundant_field_names)]
 
 #[derive(Copy, Clone)]
 struct Foo(u32);

tests/ui/used_underscore_binding.rs

@@ -2,7 +2,7 @@
 
 #![feature(rustc_private)]
 #![warn(clippy::all)]
-#![allow(clippy::disallowed_name, clippy::eq_op)]
+#![allow(clippy::disallowed_names, clippy::eq_op)]
 #![warn(clippy::used_underscore_binding)]
 
 #[macro_use]