rustup https://github.com/rust-lang/rust/pull/57726

clippy_lints/src/approx_const.rs

@@ -60,6 +60,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(APPROX_CONSTANT)
     }
+
+    fn name(&self) -> &'static str {
+        "ApproxConstant"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/arithmetic.rs

@@ -52,6 +52,10 @@ impl LintPass for Arithmetic {
     fn get_lints(&self) -> LintArray {
         lint_array!(INTEGER_ARITHMETIC, FLOAT_ARITHMETIC)
     }
+
+    fn name(&self) -> &'static str {
+        "Arithmetic"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {

clippy_lints/src/assertions_on_constants.rs

@@ -34,6 +34,10 @@ impl LintPass for AssertionsOnConstants {
     fn get_lints(&self) -> LintArray {
         lint_array![ASSERTIONS_ON_CONSTANTS]
     }
+
+    fn name(&self) -> &'static str {
+        "AssertionsOnConstants"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssertionsOnConstants {

clippy_lints/src/assign_ops.rs

@@ -57,6 +57,10 @@ impl LintPass for AssignOps {
     fn get_lints(&self) -> LintArray {
         lint_array!(ASSIGN_OP_PATTERN, MISREFACTORED_ASSIGN_OP)
     }
+
+    fn name(&self) -> &'static str {
+        "AssignOps"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {

clippy_lints/src/attrs.rs

@@ -199,6 +199,10 @@ impl LintPass for AttrPass {
             UNKNOWN_CLIPPY_LINTS,
         )
     }
+
+    fn name(&self) -> &'static str {
+        "Attributes"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass {
@@ -500,6 +504,10 @@ impl LintPass for CfgAttrPass {
     fn get_lints(&self) -> LintArray {
         lint_array!(DEPRECATED_CFG_ATTR,)
     }
+
+    fn name(&self) -> &'static str {
+        "DeprecatedCfgAttribute"
+    }
 }
 
 impl EarlyLintPass for CfgAttrPass {

clippy_lints/src/bit_mask.rs

@@ -108,6 +108,9 @@ impl LintPass for BitMask {
     fn get_lints(&self) -> LintArray {
         lint_array!(BAD_BIT_MASK, INEFFECTIVE_BIT_MASK, VERBOSE_BIT_MASK)
     }
+    fn name(&self) -> &'static str {
+        "BitMask"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BitMask {

clippy_lints/src/blacklisted_name.rs

@@ -37,6 +37,9 @@ impl LintPass for BlackListedName {
     fn get_lints(&self) -> LintArray {
         lint_array!(BLACKLISTED_NAME)
     }
+    fn name(&self) -> &'static str {
+        "BlacklistedName"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlackListedName {

clippy_lints/src/block_in_if_condition.rs

@@ -49,6 +49,10 @@ impl LintPass for BlockInIfCondition {
     fn get_lints(&self) -> LintArray {
         lint_array!(BLOCK_IN_IF_CONDITION_EXPR, BLOCK_IN_IF_CONDITION_STMT)
     }
+
+    fn name(&self) -> &'static str {
+        "BlockInIfCondition"
+    }
 }
 
 struct ExVisitor<'a, 'tcx: 'a> {

clippy_lints/src/booleans.rs

@@ -58,6 +58,10 @@ impl LintPass for NonminimalBool {
     fn get_lints(&self) -> LintArray {
         lint_array!(NONMINIMAL_BOOL, LOGIC_BUG)
     }
+
+    fn name(&self) -> &'static str {
+        "NonminimalBool"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonminimalBool {

clippy_lints/src/bytecount.rs

@@ -38,6 +38,10 @@ impl LintPass for ByteCount {
     fn get_lints(&self) -> LintArray {
         lint_array!(NAIVE_BYTECOUNT)
     }
+
+    fn name(&self) -> &'static str {
+        "ByteCount"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {

clippy_lints/src/cargo_common_metadata.rs

@@ -62,6 +62,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(CARGO_COMMON_METADATA)
     }
+
+    fn name(&self) -> &'static str {
+        "CargoCommonMetadata"
+    }
 }
 
 impl EarlyLintPass for Pass {

clippy_lints/src/collapsible_if.rs

@@ -78,6 +78,10 @@ impl LintPass for CollapsibleIf {
     fn get_lints(&self) -> LintArray {
         lint_array!(COLLAPSIBLE_IF)
     }
+
+    fn name(&self) -> &'static str {
+        "CollapsibleIf"
+    }
 }
 
 impl EarlyLintPass for CollapsibleIf {

clippy_lints/src/const_static_lifetime.rs

@@ -32,6 +32,10 @@ impl LintPass for StaticConst {
     fn get_lints(&self) -> LintArray {
         lint_array!(CONST_STATIC_LIFETIME)
     }
+
+    fn name(&self) -> &'static str {
+        "StaticConst"
+    }
 }
 
 impl StaticConst {

clippy_lints/src/copies.rs

@@ -110,6 +110,10 @@ impl LintPass for CopyAndPaste {
     fn get_lints(&self) -> LintArray {
         lint_array![IFS_SAME_COND, IF_SAME_THEN_ELSE, MATCH_SAME_ARMS]
     }
+
+    fn name(&self) -> &'static str {
+        "CopyAndPaste"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyAndPaste {

clippy_lints/src/copy_iterator.rs

@@ -35,6 +35,10 @@ impl LintPass for CopyIterator {
     fn get_lints(&self) -> LintArray {
         lint_array![COPY_ITERATOR]
     }
+
+    fn name(&self) -> &'static str {
+        "CopyIterator"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyIterator {

clippy_lints/src/cyclomatic_complexity.rs

@@ -42,6 +42,10 @@ impl LintPass for CyclomaticComplexity {
     fn get_lints(&self) -> LintArray {
         lint_array!(CYCLOMATIC_COMPLEXITY)
     }
+
+    fn name(&self) -> &'static str {
+        "CyclomaticComplexity"
+    }
 }
 
 impl CyclomaticComplexity {

clippy_lints/src/default_trait_access.rs

@@ -35,6 +35,10 @@ impl LintPass for DefaultTraitAccess {
     fn get_lints(&self) -> LintArray {
         lint_array!(DEFAULT_TRAIT_ACCESS)
     }
+
+    fn name(&self) -> &'static str {
+        "DefaultTraitAccess"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DefaultTraitAccess {

clippy_lints/src/derive.rs

@@ -68,6 +68,10 @@ impl LintPass for Derive {
     fn get_lints(&self) -> LintArray {
         lint_array!(EXPL_IMPL_CLONE_ON_COPY, DERIVE_HASH_XOR_EQ)
     }
+
+    fn name(&self) -> &'static str {
+        "Derive"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Derive {

clippy_lints/src/doc.rs

@@ -48,6 +48,10 @@ impl LintPass for Doc {
     fn get_lints(&self) -> LintArray {
         lint_array![DOC_MARKDOWN]
     }
+
+    fn name(&self) -> &'static str {
+        "DocMarkdown"
+    }
 }
 
 impl EarlyLintPass for Doc {

clippy_lints/src/double_comparison.rs

@@ -37,6 +37,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(DOUBLE_COMPARISONS)
     }
+
+    fn name(&self) -> &'static str {
+        "DoubleComparisons"
+    }
 }
 
 impl<'a, 'tcx> Pass {

clippy_lints/src/double_parens.rs

@@ -29,6 +29,10 @@ impl LintPass for DoubleParens {
     fn get_lints(&self) -> LintArray {
         lint_array!(DOUBLE_PARENS)
     }
+
+    fn name(&self) -> &'static str {
+        "DoubleParens"
+    }
 }
 
 impl EarlyLintPass for DoubleParens {

clippy_lints/src/drop_forget_ref.rs

@@ -112,6 +112,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(DROP_REF, FORGET_REF, DROP_COPY, FORGET_COPY)
     }
+
+    fn name(&self) -> &'static str {
+        "DropForgetRef"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/duration_subsec.rs

@@ -36,6 +36,10 @@ impl LintPass for DurationSubsec {
     fn get_lints(&self) -> LintArray {
         lint_array!(DURATION_SUBSEC)
     }
+
+    fn name(&self) -> &'static str {
+        "DurationSubsec"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DurationSubsec {

clippy_lints/src/else_if_without_else.rs

@@ -46,6 +46,10 @@ impl LintPass for ElseIfWithoutElse {
     fn get_lints(&self) -> LintArray {
         lint_array!(ELSE_IF_WITHOUT_ELSE)
     }
+
+    fn name(&self) -> &'static str {
+        "ElseIfWithoutElse"
+    }
 }
 
 impl EarlyLintPass for ElseIfWithoutElse {

clippy_lints/src/empty_enum.rs

@@ -30,6 +30,10 @@ impl LintPass for EmptyEnum {
     fn get_lints(&self) -> LintArray {
         lint_array!(EMPTY_ENUM)
     }
+
+    fn name(&self) -> &'static str {
+        "EmptyEnum"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EmptyEnum {

clippy_lints/src/entry.rs

@@ -44,6 +44,10 @@ impl LintPass for HashMapLint {
     fn get_lints(&self) -> LintArray {
         lint_array!(MAP_ENTRY)
     }
+
+    fn name(&self) -> &'static str {
+        "HashMap"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for HashMapLint {

clippy_lints/src/enum_clike.rs

@@ -40,6 +40,10 @@ impl LintPass for UnportableVariant {
     fn get_lints(&self) -> LintArray {
         lint_array!(ENUM_CLIKE_UNPORTABLE_VARIANT)
     }
+
+    fn name(&self) -> &'static str {
+        "UnportableVariant"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnportableVariant {

clippy_lints/src/enum_glob_use.rs

@@ -32,6 +32,10 @@ impl LintPass for EnumGlobUse {
     fn get_lints(&self) -> LintArray {
         lint_array!(ENUM_GLOB_USE)
     }
+
+    fn name(&self) -> &'static str {
+        "EnumGlobUse"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EnumGlobUse {

clippy_lints/src/enum_variants.rs

@@ -124,6 +124,10 @@ impl LintPass for EnumVariantNames {
             MODULE_INCEPTION
         )
     }
+
+    fn name(&self) -> &'static str {
+        "EnumVariantNames"
+    }
 }
 
 fn var2str(var: &Variant) -> LocalInternedString {

clippy_lints/src/eq_op.rs

@@ -52,6 +52,10 @@ impl LintPass for EqOp {
     fn get_lints(&self) -> LintArray {
         lint_array!(EQ_OP, OP_REF)
     }
+
+    fn name(&self) -> &'static str {
+        "EqOp"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {

clippy_lints/src/erasing_op.rs

@@ -32,6 +32,10 @@ impl LintPass for ErasingOp {
     fn get_lints(&self) -> LintArray {
         lint_array!(ERASING_OP)
     }
+
+    fn name(&self) -> &'static str {
+        "ErasingOp"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ErasingOp {

clippy_lints/src/escape.rs

@@ -52,6 +52,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(BOXED_LOCAL)
     }
+
+    fn name(&self) -> &'static str {
+        "BoxedLocal"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/eta_reduction.rs

@@ -36,6 +36,10 @@ impl LintPass for EtaPass {
     fn get_lints(&self) -> LintArray {
         lint_array!(REDUNDANT_CLOSURE)
     }
+
+    fn name(&self) -> &'static str {
+        "EtaReduction"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EtaPass {

clippy_lints/src/eval_order_dependence.rs

@@ -61,6 +61,10 @@ impl LintPass for EvalOrderDependence {
     fn get_lints(&self) -> LintArray {
         lint_array!(EVAL_ORDER_DEPENDENCE, DIVERGING_SUB_EXPRESSION)
     }
+
+    fn name(&self) -> &'static str {
+        "EvalOrderDependence"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence {

clippy_lints/src/excessive_precision.rs

@@ -41,6 +41,10 @@ impl LintPass for ExcessivePrecision {
     fn get_lints(&self) -> LintArray {
         lint_array!(EXCESSIVE_PRECISION)
     }
+
+    fn name(&self) -> &'static str {
+        "ExcessivePrecision"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ExcessivePrecision {

clippy_lints/src/explicit_write.rs

@@ -31,6 +31,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(EXPLICIT_WRITE)
     }
+
+    fn name(&self) -> &'static str {
+        "ExplicitWrite"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/fallible_impl_from.rs

@@ -34,6 +34,10 @@ impl LintPass for FallibleImplFrom {
     fn get_lints(&self) -> LintArray {
         lint_array!(FALLIBLE_IMPL_FROM)
     }
+
+    fn name(&self) -> &'static str {
+        "FallibleImpleFrom"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for FallibleImplFrom {

clippy_lints/src/format.rs

@@ -40,6 +40,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array![USELESS_FORMAT]
     }
+
+    fn name(&self) -> &'static str {
+        "UselessFormat"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/formatting.rs

@@ -89,6 +89,10 @@ impl LintPass for Formatting {
             POSSIBLE_MISSING_COMMA
         )
     }
+
+    fn name(&self) -> &'static str {
+        "Formatting"
+    }
 }
 
 impl EarlyLintPass for Formatting {

clippy_lints/src/functions.rs

@@ -74,6 +74,10 @@ impl LintPass for Functions {
     fn get_lints(&self) -> LintArray {
         lint_array!(TOO_MANY_ARGUMENTS, NOT_UNSAFE_PTR_ARG_DEREF)
     }
+
+    fn name(&self) -> &'static str {
+        "Functions"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions {

clippy_lints/src/identity_conversion.rs

@@ -34,6 +34,10 @@ impl LintPass for IdentityConversion {
     fn get_lints(&self) -> LintArray {
         lint_array!(IDENTITY_CONVERSION)
     }
+
+    fn name(&self) -> &'static str {
+        "IdentityConversion"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityConversion {

clippy_lints/src/identity_op.rs

@@ -30,6 +30,10 @@ impl LintPass for IdentityOp {
     fn get_lints(&self) -> LintArray {
         lint_array!(IDENTITY_OP)
     }
+
+    fn name(&self) -> &'static str {
+        "IdentityOp"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityOp {

clippy_lints/src/if_not_else.rs

@@ -44,6 +44,10 @@ impl LintPass for IfNotElse {
     fn get_lints(&self) -> LintArray {
         lint_array!(IF_NOT_ELSE)
     }
+
+    fn name(&self) -> &'static str {
+        "IfNotElse"
+    }
 }
 
 impl EarlyLintPass for IfNotElse {

clippy_lints/src/implicit_return.rs

@@ -114,6 +114,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(IMPLICIT_RETURN)
     }
+
+    fn name(&self) -> &'static str {
+        "ImplicitReturn"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/indexing_slicing.rs

@@ -91,6 +91,10 @@ impl LintPass for IndexingSlicing {
     fn get_lints(&self) -> LintArray {
         lint_array!(INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING)
     }
+
+    fn name(&self) -> &'static str {
+        "IndexSlicing"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IndexingSlicing {

clippy_lints/src/infallible_destructuring_match.rs

@@ -47,6 +47,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(INFALLIBLE_DESTRUCTURING_MATCH)
     }
+
+    fn name(&self) -> &'static str {
+        "InfallibleDestructingMatch"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/infinite_iter.rs

@@ -45,6 +45,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(INFINITE_ITER, MAYBE_INFINITE_ITER)
     }
+
+    fn name(&self) -> &'static str {
+        "InfiniteIter"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/inherent_impl.rs

@@ -56,6 +56,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(MULTIPLE_INHERENT_IMPL)
     }
+
+    fn name(&self) -> &'static str {
+        "MultipleInherientImpl"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/inline_fn_without_body.rs

@@ -35,6 +35,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(INLINE_FN_WITHOUT_BODY)
     }
+
+    fn name(&self) -> &'static str {
+        "InlineFnWithoutBody"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/int_plus_one.rs

@@ -36,6 +36,10 @@ impl LintPass for IntPlusOne {
     fn get_lints(&self) -> LintArray {
         lint_array!(INT_PLUS_ONE)
     }
+
+    fn name(&self) -> &'static str {
+        "IntPlusOne"
+    }
 }
 
 // cases:

clippy_lints/src/invalid_ref.rs

@@ -32,6 +32,10 @@ impl LintPass for InvalidRef {
     fn get_lints(&self) -> LintArray {
         lint_array!(INVALID_REF)
     }
+
+    fn name(&self) -> &'static str {
+        "InvalidRef"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidRef {

clippy_lints/src/items_after_statements.rs

@@ -40,6 +40,10 @@ impl LintPass for ItemsAfterStatements {
     fn get_lints(&self) -> LintArray {
         lint_array!(ITEMS_AFTER_STATEMENTS)
     }
+
+    fn name(&self) -> &'static str {
+        "ItemsAfterStatements"
+    }
 }
 
 impl EarlyLintPass for ItemsAfterStatements {

clippy_lints/src/large_enum_variant.rs

@@ -46,6 +46,10 @@ impl LintPass for LargeEnumVariant {
     fn get_lints(&self) -> LintArray {
         lint_array!(LARGE_ENUM_VARIANT)
     }
+
+    fn name(&self) -> &'static str {
+        "LargeEnumVariant"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LargeEnumVariant {

clippy_lints/src/len_zero.rs

@@ -77,6 +77,10 @@ impl LintPass for LenZero {
     fn get_lints(&self) -> LintArray {
         lint_array!(LEN_ZERO, LEN_WITHOUT_IS_EMPTY)
     }
+
+    fn name(&self) -> &'static str {
+        "LenZero"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LenZero {

clippy_lints/src/let_if_seq.rs

@@ -60,6 +60,10 @@ impl LintPass for LetIfSeq {
     fn get_lints(&self) -> LintArray {
         lint_array!(USELESS_LET_IF_SEQ)
     }
+
+    fn name(&self) -> &'static str {
+        "LetIfSeq"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq {

clippy_lints/src/lib.rs

@@ -212,15 +212,22 @@ pub fn register_pre_expansion_lints(
     store: &mut rustc::lint::LintStore,
     conf: &Conf,
 ) {
-    store.register_pre_expansion_pass(Some(session), box write::Pass);
-    store.register_pre_expansion_pass(Some(session), box redundant_field_names::RedundantFieldNames);
+    store.register_pre_expansion_pass(Some(session), true, false, box write::Pass);
     store.register_pre_expansion_pass(
         Some(session),
+        true,
+        false,
+        box redundant_field_names::RedundantFieldNames,
+    );
+    store.register_pre_expansion_pass(
+        Some(session),
+        true,
+        false,
         box non_expressive_names::NonExpressiveNames {
             single_char_binding_names_threshold: conf.single_char_binding_names_threshold,
         },
     );
-    store.register_pre_expansion_pass(Some(session), box attrs::CfgAttrPass);
+    store.register_pre_expansion_pass(Some(session), true, false, box attrs::CfgAttrPass);
 }
 
 pub fn read_conf(reg: &rustc_plugin::Registry<'_>) -> Conf {

clippy_lints/src/lifetimes.rs

@@ -61,6 +61,10 @@ impl LintPass for LifetimePass {
     fn get_lints(&self) -> LintArray {
         lint_array!(NEEDLESS_LIFETIMES, EXTRA_UNUSED_LIFETIMES)
     }
+
+    fn name(&self) -> &'static str {
+        "LifeTimes"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LifetimePass {

clippy_lints/src/literal_representation.rs

@@ -346,6 +346,10 @@ impl LintPass for LiteralDigitGrouping {
             MISTYPED_LITERAL_SUFFIXES,
         )
     }
+
+    fn name(&self) -> &'static str {
+        "LiteralDigitGrouping"
+    }
 }
 
 impl EarlyLintPass for LiteralDigitGrouping {
@@ -493,6 +497,10 @@ impl LintPass for LiteralRepresentation {
     fn get_lints(&self) -> LintArray {
         lint_array!(DECIMAL_LITERAL_REPRESENTATION)
     }
+
+    fn name(&self) -> &'static str {
+        "DecimalLiteralRepresentation"
+    }
 }
 
 impl EarlyLintPass for LiteralRepresentation {

clippy_lints/src/loops.rs

@@ -465,6 +465,10 @@ impl LintPass for Pass {
             WHILE_IMMUTABLE_CONDITION,
         )
     }
+
+    fn name(&self) -> &'static str {
+        "Loops"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/map_clone.rs

@@ -46,6 +46,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(MAP_CLONE)
     }
+
+    fn name(&self) -> &'static str {
+        "MapClone"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/map_unit_fn.rs

@@ -81,6 +81,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(OPTION_MAP_UNIT_FN, RESULT_MAP_UNIT_FN)
     }
+
+    fn name(&self) -> &'static str {
+        "MapUnit"
+    }
 }
 
 fn is_unit_type(ty: ty::Ty<'_>) -> bool {

clippy_lints/src/matches.rs

@@ -202,6 +202,10 @@ impl LintPass for MatchPass {
             MATCH_AS_REF
         )
     }
+
+    fn name(&self) -> &'static str {
+        "Matches"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MatchPass {

clippy_lints/src/mem_discriminant.rs

@@ -31,6 +31,10 @@ impl LintPass for MemDiscriminant {
     fn get_lints(&self) -> LintArray {
         lint_array![MEM_DISCRIMINANT_NON_ENUM]
     }
+
+    fn name(&self) -> &'static str {
+        "MemDiscriminant"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MemDiscriminant {

clippy_lints/src/mem_forget.rs

@@ -27,6 +27,10 @@ impl LintPass for MemForget {
     fn get_lints(&self) -> LintArray {
         lint_array![MEM_FORGET]
     }
+
+    fn name(&self) -> &'static str {
+        "MemForget"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MemForget {

clippy_lints/src/mem_replace.rs

@@ -36,6 +36,10 @@ impl LintPass for MemReplace {
     fn get_lints(&self) -> LintArray {
         lint_array![MEM_REPLACE_OPTION_WITH_NONE]
     }
+
+    fn name(&self) -> &'static str {
+        "MemReplace"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MemReplace {

clippy_lints/src/methods/mod.rs

@@ -814,6 +814,10 @@ impl LintPass for Pass {
             INTO_ITER_ON_REF,
         )
     }
+
+    fn name(&self) -> &'static str {
+        "Methods"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/minmax.rs

@@ -31,6 +31,10 @@ impl LintPass for MinMaxPass {
     fn get_lints(&self) -> LintArray {
         lint_array!(MIN_MAX)
     }
+
+    fn name(&self) -> &'static str {
+        "MinMax"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MinMaxPass {

clippy_lints/src/misc.rs

@@ -242,6 +242,10 @@ impl LintPass for Pass {
             FLOAT_CMP_CONST
         )
     }
+
+    fn name(&self) -> &'static str {
+        "MiscLints"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/misc_early.rs

@@ -187,6 +187,10 @@ impl LintPass for MiscEarly {
             BUILTIN_TYPE_SHADOW
         )
     }
+
+    fn name(&self) -> &'static str {
+        "MiscEarlyLints"
+    }
 }
 
 // Used to find `return` statements or equivalents e.g. `?`

clippy_lints/src/missing_doc.rs

@@ -90,6 +90,10 @@ impl LintPass for MissingDoc {
     fn get_lints(&self) -> LintArray {
         lint_array![MISSING_DOCS_IN_PRIVATE_ITEMS]
     }
+
+    fn name(&self) -> &'static str {
+        "MissingDoc"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {

clippy_lints/src/missing_inline.rs

@@ -83,6 +83,10 @@ impl LintPass for MissingInline {
     fn get_lints(&self) -> LintArray {
         lint_array![MISSING_INLINE_IN_PUBLIC_ITEMS]
     }
+
+    fn name(&self) -> &'static str {
+        "MissingInline"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingInline {

clippy_lints/src/multiple_crate_versions.rs

@@ -37,6 +37,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(MULTIPLE_CRATE_VERSIONS)
     }
+
+    fn name(&self) -> &'static str {
+        "MultipleCrateVersions"
+    }
 }
 
 impl EarlyLintPass for Pass {

clippy_lints/src/mut_mut.rs

@@ -30,6 +30,10 @@ impl LintPass for MutMut {
     fn get_lints(&self) -> LintArray {
         lint_array!(MUT_MUT)
     }
+
+    fn name(&self) -> &'static str {
+        "MutMut"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MutMut {

clippy_lints/src/mut_reference.rs

@@ -30,6 +30,10 @@ impl LintPass for UnnecessaryMutPassed {
     fn get_lints(&self) -> LintArray {
         lint_array!(UNNECESSARY_MUT_PASSED)
     }
+
+    fn name(&self) -> &'static str {
+        "UnneccessaryMutPassed"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnecessaryMutPassed {

clippy_lints/src/mutex_atomic.rs

@@ -53,6 +53,10 @@ impl LintPass for MutexAtomic {
     fn get_lints(&self) -> LintArray {
         lint_array!(MUTEX_ATOMIC, MUTEX_INTEGER)
     }
+
+    fn name(&self) -> &'static str {
+        "Mutex"
+    }
 }
 
 pub struct MutexAtomic;

clippy_lints/src/needless_bool.rs

@@ -61,6 +61,10 @@ impl LintPass for NeedlessBool {
     fn get_lints(&self) -> LintArray {
         lint_array!(NEEDLESS_BOOL)
     }
+
+    fn name(&self) -> &'static str {
+        "NeedlessBool"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool {
@@ -141,6 +145,10 @@ impl LintPass for BoolComparison {
     fn get_lints(&self) -> LintArray {
         lint_array!(BOOL_COMPARISON)
     }
+
+    fn name(&self) -> &'static str {
+        "BoolComparison"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison {

clippy_lints/src/needless_borrow.rs

@@ -39,6 +39,10 @@ impl LintPass for NeedlessBorrow {
     fn get_lints(&self) -> LintArray {
         lint_array!(NEEDLESS_BORROW)
     }
+
+    fn name(&self) -> &'static str {
+        "NeedlessBorrow"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrow {

clippy_lints/src/needless_borrowed_ref.rs

@@ -58,6 +58,10 @@ impl LintPass for NeedlessBorrowedRef {
     fn get_lints(&self) -> LintArray {
         lint_array!(NEEDLESS_BORROWED_REFERENCE)
     }
+
+    fn name(&self) -> &'static str {
+        "NeedlessBorrowedRef"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrowedRef {

clippy_lints/src/needless_continue.rs

@@ -107,6 +107,10 @@ impl LintPass for NeedlessContinue {
     fn get_lints(&self) -> LintArray {
         lint_array!(NEEDLESS_CONTINUE)
     }
+
+    fn name(&self) -> &'static str {
+        "NeedlessContinue"
+    }
 }
 
 impl EarlyLintPass for NeedlessContinue {

clippy_lints/src/needless_pass_by_value.rs

@@ -56,6 +56,10 @@ impl LintPass for NeedlessPassByValue {
     fn get_lints(&self) -> LintArray {
         lint_array![NEEDLESS_PASS_BY_VALUE]
     }
+
+    fn name(&self) -> &'static str {
+        "NeedlessPassByValue"
+    }
 }
 
 macro_rules! need {

clippy_lints/src/needless_update.rs

@@ -33,6 +33,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(NEEDLESS_UPDATE)
     }
+
+    fn name(&self) -> &'static str {
+        "NeedUpdate"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/neg_cmp_op_on_partial_ord.rs

@@ -48,6 +48,10 @@ impl LintPass for NoNegCompOpForPartialOrd {
     fn get_lints(&self) -> LintArray {
         lint_array!(NEG_CMP_OP_ON_PARTIAL_ORD)
     }
+
+    fn name(&self) -> &'static str {
+        "NoNegCompOpForPartialOrd"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NoNegCompOpForPartialOrd {

clippy_lints/src/neg_multiply.rs

@@ -30,6 +30,10 @@ impl LintPass for NegMultiply {
     fn get_lints(&self) -> LintArray {
         lint_array!(NEG_MULTIPLY)
     }
+
+    fn name(&self) -> &'static str {
+        "NegMultiply"
+    }
 }
 
 #[allow(clippy::match_same_arms)]

clippy_lints/src/new_without_default.rs

@@ -93,6 +93,10 @@ impl LintPass for NewWithoutDefault {
     fn get_lints(&self) -> LintArray {
         lint_array!(NEW_WITHOUT_DEFAULT)
     }
+
+    fn name(&self) -> &'static str {
+        "NewWithoutDefault"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NewWithoutDefault {

clippy_lints/src/no_effect.rs

@@ -100,6 +100,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(NO_EFFECT, UNNECESSARY_OPERATION)
     }
+
+    fn name(&self) -> &'static str {
+        "NoEffect"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/non_copy_const.rs

@@ -147,6 +147,10 @@ impl LintPass for NonCopyConst {
     fn get_lints(&self) -> LintArray {
         lint_array!(DECLARE_INTERIOR_MUTABLE_CONST, BORROW_INTERIOR_MUTABLE_CONST)
     }
+
+    fn name(&self) -> &'static str {
+        "NonCopyConst"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonCopyConst {

clippy_lints/src/non_expressive_names.rs

@@ -71,6 +71,10 @@ impl LintPass for NonExpressiveNames {
     fn get_lints(&self) -> LintArray {
         lint_array!(SIMILAR_NAMES, MANY_SINGLE_CHAR_NAMES, JUST_UNDERSCORES_AND_DIGITS)
     }
+
+    fn name(&self) -> &'static str {
+        "NoneExpressiveNames"
+    }
 }
 
 struct ExistingName {

clippy_lints/src/ok_if_let.rs

@@ -41,6 +41,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(IF_LET_SOME_RESULT)
     }
+
+    fn name(&self) -> &'static str {
+        "OkIfLet"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/open_options.rs

@@ -30,6 +30,10 @@ impl LintPass for NonSensical {
     fn get_lints(&self) -> LintArray {
         lint_array!(NONSENSICAL_OPEN_OPTIONS)
     }
+
+    fn name(&self) -> &'static str {
+        "OpenOptions"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSensical {

clippy_lints/src/overflow_check_conditional.rs

@@ -28,6 +28,10 @@ impl LintPass for OverflowCheckConditional {
     fn get_lints(&self) -> LintArray {
         lint_array!(OVERFLOW_CHECK_CONDITIONAL)
     }
+
+    fn name(&self) -> &'static str {
+        "OverflowCheckConditional"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OverflowCheckConditional {

clippy_lints/src/panic_unimplemented.rs

@@ -48,6 +48,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(PANIC_PARAMS, UNIMPLEMENTED)
     }
+
+    fn name(&self) -> &'static str {
+        "PanicUnimplemented"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/partialeq_ne_impl.rs

@@ -35,6 +35,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(PARTIALEQ_NE_IMPL)
     }
+
+    fn name(&self) -> &'static str {
+        "PartialEqNeImpl"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/precedence.rs

@@ -35,6 +35,10 @@ impl LintPass for Precedence {
     fn get_lints(&self) -> LintArray {
         lint_array!(PRECEDENCE)
     }
+
+    fn name(&self) -> &'static str {
+        "Precedence"
+    }
 }
 
 impl EarlyLintPass for Precedence {

clippy_lints/src/ptr.rs

@@ -102,6 +102,10 @@ impl LintPass for PointerPass {
     fn get_lints(&self) -> LintArray {
         lint_array!(PTR_ARG, CMP_NULL, MUT_FROM_REF)
     }
+
+    fn name(&self) -> &'static str {
+        "Ptr"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PointerPass {

clippy_lints/src/ptr_offset_with_cast.rs

@@ -46,6 +46,10 @@ impl lint::LintPass for Pass {
     fn get_lints(&self) -> lint::LintArray {
         lint_array!(PTR_OFFSET_WITH_CAST)
     }
+
+    fn name(&self) -> &'static str {
+        "PtrOffsetWithCast"
+    }
 }
 
 impl<'a, 'tcx> lint::LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/question_mark.rs

@@ -41,6 +41,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(QUESTION_MARK)
     }
+
+    fn name(&self) -> &'static str {
+        "QuestionMark"
+    }
 }
 
 impl Pass {

clippy_lints/src/ranges.rs

@@ -97,6 +97,10 @@ impl LintPass for Pass {
             RANGE_MINUS_ONE
         )
     }
+
+    fn name(&self) -> &'static str {
+        "Ranges"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {

clippy_lints/src/redundant_clone.rs

@@ -73,6 +73,10 @@ impl LintPass for RedundantClone {
     fn get_lints(&self) -> LintArray {
         lint_array!(REDUNDANT_CLONE)
     }
+
+    fn name(&self) -> &'static str {
+        "RedundantClone"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RedundantClone {

clippy_lints/src/redundant_field_names.rs

@@ -38,6 +38,10 @@ impl LintPass for RedundantFieldNames {
     fn get_lints(&self) -> LintArray {
         lint_array!(REDUNDANT_FIELD_NAMES)
     }
+
+    fn name(&self) -> &'static str {
+        "RedundantFieldNames"
+    }
 }
 
 impl EarlyLintPass for RedundantFieldNames {

clippy_lints/src/redundant_pattern_matching.rs

@@ -49,6 +49,10 @@ impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
         lint_array!(REDUNDANT_PATTERN_MATCHING)
     }
+
+    fn name(&self) -> &'static str {
+        "RedundantPatternMatching"
+    }
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {