diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 41099f94b044..58a644bd6114 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -577,7 +577,12 @@ define_Conf! {
     #[lints(inconsistent_struct_constructor)]
     check_inconsistent_struct_field_initializers: bool = false,
     /// Whether to also run the listed lints on private items.
-    #[lints(missing_errors_doc, missing_panics_doc, missing_safety_doc, unnecessary_safety_doc)]
+    #[lints(
+        missing_errors_doc,
+        missing_panics_doc,
+        missing_safety_doc,
+        unnecessary_safety_doc,
+    )]
     check_private_items: bool = false,
     /// The maximum cognitive complexity a function can have
     #[lints(cognitive_complexity)]
@@ -684,7 +689,12 @@ define_Conf! {
     #[lints(large_futures)]
     future_size_threshold: u64 = 16 * 1024,
     /// A list of paths to types that should be treated as if they do not contain interior mutability
-    #[lints(borrow_interior_mutable_const, declare_interior_mutable_const, ifs_same_cond, mutable_key_type)]
+    #[lints(
+        borrow_interior_mutable_const,
+        declare_interior_mutable_const,
+        ifs_same_cond,
+        mutable_key_type,
+    )]
     ignore_interior_mutability: Vec<String> = Vec::from(["bytes::Bytes".into()]),
     /// Sets the scope ("crate", "file", or "module") in which duplicate inherent `impl` blocks for the same type are linted.
     #[lints(multiple_inherent_impl)]
diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index 238465210ee2..d09336b02a1c 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -5,10 +5,13 @@ version = "0.0.1"
 edition = "2024"
 
 [dependencies]
+annotate-snippets = { version = "0.12.10", features = ["simd"] }
+anstream = "0.6.20"
 chrono = { version = "0.4.38", default-features = false, features = ["clock"] }
 clap = { version = "4.4", features = ["derive"] }
 indoc = "1.0"
 itertools = "0.12"
+memchr = "2.7.6"
 opener = "0.7"
 rustc-literal-escaper = "0.0.7"
 walkdir = "2.3"
diff --git a/clippy_dev/src/diag.rs b/clippy_dev/src/diag.rs
new file mode 100644
index 000000000000..003d427d11e0
--- /dev/null
+++ b/clippy_dev/src/diag.rs
@@ -0,0 +1,153 @@
+use crate::Span;
+use annotate_snippets::renderer::{DEFAULT_TERM_WIDTH, Renderer};
+use annotate_snippets::{Annotation, AnnotationKind, Group, Level, Origin, Snippet};
+use core::panic::Location;
+use std::borrow::Cow;
+use std::io::Write as _;
+use std::process;
+
+pub struct DiagCx {
+    out: anstream::Stdout,
+    renderer: Renderer,
+    has_err: bool,
+}
+impl Default for DiagCx {
+    fn default() -> Self {
+        let width = termize::dimensions().map_or(DEFAULT_TERM_WIDTH, |(w, _)| w);
+        Self {
+            out: anstream::stdout(),
+            renderer: Renderer::styled().term_width(width),
+            has_err: false,
+        }
+    }
+}
+impl Drop for DiagCx {
+    fn drop(&mut self) {
+        if self.has_err {
+            self.render(&[
+                Group::with_title(
+                    Level::ERROR
+                        .with_name("internal error")
+                        .primary_title("errors were found, but it was assumed none occurred"),
+                ),
+                Group::with_title(Level::NOTE.secondary_title("any produced results may be incorrect")),
+            ]);
+            process::exit(1);
+        }
+    }
+}
+impl DiagCx {
+    pub fn exit_on_err(&self) {
+        if self.has_err {
+            process::exit(1);
+        }
+    }
+
+    #[track_caller]
+    pub fn exit_assume_err(&mut self) -> ! {
+        if !self.has_err {
+            self.render(&[
+                Group::with_title(
+                    Level::ERROR
+                        .with_name("internal error")
+                        .primary_title("errors were expected, but is was assumed one would occur"),
+                ),
+                mk_loc_group(),
+            ]);
+        }
+        process::exit(1);
+    }
+}
+
+fn sp_to_snip(kind: AnnotationKind, sp: Span<'_>) -> Snippet<'_, Annotation<'_>> {
+    let line_starts = sp.file.line_starts();
+    let first_line = match line_starts.binary_search(&sp.range.start) {
+        Ok(x) => x,
+        // Note: `Err(0)` isn't possible since `0` is always the first start.
+        Err(x) => x - 1,
+    };
+    let start = line_starts[first_line] as usize;
+    let last_line = match line_starts.binary_search(&sp.range.end) {
+        Ok(x) => x,
+        Err(x) => x - 1,
+    };
+    let end = line_starts
+        .get(last_line + 1)
+        .map_or(sp.file.contents.len(), |&x| x as usize);
+    Snippet::source(&sp.file.contents[start..end])
+        .line_start(first_line + 1)
+        .path(sp.file.path.get())
+        .annotation(kind.span((sp.range.start as usize - start..sp.range.end as usize - start).into()))
+}
+
+fn mk_spanned_primary<'a>(level: Level<'a>, sp: Span<'a>, msg: impl Into<Cow<'a, str>>) -> Group<'a> {
+    level
+        .primary_title(msg.into())
+        .element(sp_to_snip(AnnotationKind::Primary, sp))
+}
+
+fn mk_spanned_secondary<'a>(level: Level<'a>, sp: Span<'a>, msg: impl Into<Cow<'a, str>>) -> Group<'a> {
+    level
+        .secondary_title(msg.into())
+        .element(sp_to_snip(AnnotationKind::Context, sp))
+}
+
+#[track_caller]
+fn mk_loc_group() -> Group<'static> {
+    let loc = Location::caller();
+    Level::INFO.secondary_title("error created here").element(
+        Origin::path(loc.file())
+            .line(loc.line() as usize)
+            .char_column(loc.column() as usize),
+    )
+}
+
+impl DiagCx {
+    fn render(&mut self, groups: &[Group<'_>]) {
+        let mut s = self.renderer.render(groups);
+        s.push('\n');
+        self.out.write_all(s.as_bytes()).unwrap();
+        self.has_err = true;
+    }
+
+    #[track_caller]
+    pub fn emit_spanned_err<'a>(&mut self, sp: Span<'a>, msg: impl Into<Cow<'a, str>>) {
+        self.render(&[mk_spanned_primary(Level::ERROR, sp, msg.into()), mk_loc_group()]);
+    }
+
+    #[track_caller]
+    pub fn emit_spanless_err<'a>(&mut self, msg: impl Into<Cow<'a, str>>) {
+        self.render(&[
+            Group::with_title(Level::ERROR.primary_title(msg.into())),
+            mk_loc_group(),
+        ]);
+    }
+
+    #[track_caller]
+    pub fn emit_already_deprecated(&mut self, name: &str) {
+        self.emit_spanless_err(format!("lint `{name}` is already deprecated"));
+    }
+
+    #[track_caller]
+    pub fn emit_duplicate_lint(&mut self, sp: Span<'_>, first_sp: Span<'_>) {
+        self.render(&[
+            mk_spanned_primary(Level::ERROR, sp, "duplicate lint name declared"),
+            mk_spanned_secondary(Level::NOTE, first_sp, "previous declaration here"),
+            mk_loc_group(),
+        ]);
+    }
+
+    #[track_caller]
+    pub fn emit_not_clippy_lint_name(&mut self, sp: Span<'_>) {
+        self.render(&[
+            mk_spanned_primary(Level::ERROR, sp, "not a clippy lint name"),
+            Group::with_title(Level::HELP.secondary_title("add the `clippy::` tool prefix")),
+            mk_loc_group(),
+        ]);
+    }
+
+    #[track_caller]
+    pub fn emit_unknown_lint(&mut self, name: &str) {
+        self.emit_spanless_err(format!("unknown lint `{name}`"));
+    }
+}
diff --git a/clippy_dev/src/edit_lints.rs b/clippy_dev/src/edit_lints.rs
index 411bf530b22b..cd1ae61f88e5 100644
--- a/clippy_dev/src/edit_lints.rs
+++ b/clippy_dev/src/edit_lints.rs
@@ -1,16 +1,16 @@
 use crate::parse::cursor::{self, Capture, Cursor};
-use crate::parse::{ActiveLint, DeprecatedLint, Lint, LintData, LintName, ParseCx, RenamedLint};
-use crate::update_lints::generate_lint_files;
+use crate::parse::{ActiveLint, DeprecatedLint, Lint, LintData, LintName, ParseCx, ParsedLints, RenamedLint};
 use crate::utils::{
     ErrAction, FileUpdater, UpdateMode, UpdateStatus, Version, delete_dir_if_exists, delete_file_if_exists,
     expect_action, try_rename_dir, try_rename_file, walk_dir_no_dot_or_target,
 };
+use crate::{SourceFile, Span};
 use core::mem;
 use rustc_lexer::TokenKind;
 use std::collections::hash_map::Entry;
 use std::ffi::OsString;
-use std::fs;
 use std::path::Path;
+use std::{fs, path};
 
 /// Runs the `deprecate` command
 ///
@@ -23,50 +23,63 @@ use std::path::Path;
 /// If a file path could not read from or written to
 pub fn deprecate<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, name: &'env str, reason: &'env str) {
     let mut data = cx.parse_lint_decls();
-
     let Entry::Occupied(mut lint) = data.lints.entry(name) else {
-        eprintln!("error: failed to find lint `{name}`");
-        return;
+        cx.dcx.emit_unknown_lint(name);
+        cx.dcx.exit_assume_err();
     };
-    let Lint::Active(prev_lint) = mem::replace(
+    let prev_lint = mem::replace(
         lint.get_mut(),
-        Lint::Deprecated(DeprecatedLint {
-            reason,
-            version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
-        }),
-    ) else {
-        eprintln!("error: `{name}` is already deprecated");
-        return;
+        Lint {
+            name_sp: Span::new(data.deprecated_file, 0..0),
+            data: LintData::Deprecated(DeprecatedLint {
+                reason,
+                version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
+            }),
+        },
+    );
+    let LintData::Active(prev_lint_data) = prev_lint.data else {
+        cx.dcx.emit_already_deprecated(name);
+        cx.dcx.exit_assume_err();
     };
-
-    remove_lint_declaration(name, &prev_lint, &data, &mut FileUpdater::default());
-    generate_lint_files(UpdateMode::Change, &data);
+    cx.dcx.exit_on_err();
+
+    remove_lint_declaration(
+        name,
+        prev_lint.name_sp.file,
+        &prev_lint_data,
+        &data,
+        &mut FileUpdater::default(),
+    );
+    data.gen_decls(UpdateMode::Change);
     println!("info: `{name}` has successfully been deprecated");
     println!("note: you must run `cargo uitest` to update the test results");
 }
 
 pub fn uplift<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_name: &'env str, new_name: &'env str) {
     let mut data = cx.parse_lint_decls();
-
-    update_rename_targets(&mut data, old_name, LintName::new_rustc(new_name));
-
     let Entry::Occupied(mut lint) = data.lints.entry(old_name) else {
-        eprintln!("error: failed to find lint `{old_name}`");
-        return;
+        cx.dcx.emit_unknown_lint(old_name);
+        cx.dcx.exit_assume_err();
     };
-    let Lint::Active(prev_lint) = mem::replace(
+    let prev_lint = mem::replace(
         lint.get_mut(),
-        Lint::Renamed(RenamedLint {
-            new_name: LintName::new_rustc(new_name),
-            version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
-        }),
-    ) else {
-        eprintln!("error: `{old_name}` is already deprecated");
-        return;
+        Lint {
+            name_sp: Span::new(data.deprecated_file, 0..0),
+            data: LintData::Renamed(RenamedLint {
+                new_name: LintName::new_rustc(new_name),
+                version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
+            }),
+        },
+    );
+    let LintData::Active(prev_lint_data) = prev_lint.data else {
+        cx.dcx.emit_already_deprecated(old_name);
+        cx.dcx.exit_assume_err();
     };
+    cx.dcx.exit_on_err();
 
+    update_rename_targets(&mut data, old_name, LintName::new_rustc(new_name));
     let mut updater = FileUpdater::default();
-    let remove_mod = remove_lint_declaration(old_name, &prev_lint, &data, &mut updater);
+    let remove_mod = remove_lint_declaration(old_name, prev_lint.name_sp.file, &prev_lint_data, &data, &mut updater);
     let mut update_fn = uplift_update_fn(old_name, new_name, remove_mod);
     for e in walk_dir_no_dot_or_target(".") {
         let e = expect_action(e, ErrAction::Read, ".");
@@ -74,7 +87,7 @@ pub fn uplift<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
             updater.update_file(e.path(), &mut update_fn);
         }
     }
-    generate_lint_files(UpdateMode::Change, &data);
+    data.gen_decls(UpdateMode::Change);
     println!("info: `{old_name}` has successfully been uplifted as `{new_name}`");
     println!("note: you must run `cargo uitest` to update the test results");
 }
@@ -95,48 +108,44 @@ pub fn uplift<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
 /// * If `old_name` doesn't name an existing lint.
 /// * If `old_name` names a deprecated or renamed lint.
 pub fn rename<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_name: &'env str, new_name: &'env str) {
-    let mut updater = FileUpdater::default();
     let mut data = cx.parse_lint_decls();
-
-    update_rename_targets(&mut data, old_name, LintName::new_clippy(new_name));
-
     let Entry::Occupied(mut lint) = data.lints.entry(old_name) else {
-        eprintln!("error: failed to find lint `{old_name}`");
-        return;
+        cx.dcx.emit_unknown_lint(old_name);
+        cx.dcx.exit_assume_err();
     };
-    let Lint::Active(mut prev_lint) = mem::replace(
+    let prev_lint = mem::replace(
         lint.get_mut(),
-        Lint::Renamed(RenamedLint {
-            new_name: LintName::new_clippy(new_name),
-            version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
-        }),
-    ) else {
-        eprintln!("error: `{old_name}` is already deprecated");
-        return;
-    };
+        Lint {
+            name_sp: Span::new(data.deprecated_file, 0..0),
+            data: LintData::Renamed(RenamedLint {
+                new_name: LintName::new_clippy(new_name),
+                version: cx.str_buf.alloc_display(cx.arena, clippy_version.rust_display()),
+            }),
+        },
+    );
+    if !matches!(prev_lint.data, LintData::Active(_)) {
+        cx.dcx.emit_already_deprecated(old_name);
+    }
+    cx.dcx.exit_on_err();
 
+    update_rename_targets(&mut data, old_name, LintName::new_clippy(new_name));
+    let mut updater = FileUpdater::default();
+    let prev_file = prev_lint.name_sp.file;
     let mut rename_mod = false;
     if let Entry::Vacant(e) = data.lints.entry(new_name) {
-        if prev_lint.module.ends_with(old_name)
-            && prev_lint
-                .path
-                .file_stem()
-                .is_some_and(|x| x.as_encoded_bytes() == old_name.as_bytes())
+        if let Some((path, file)) = prev_file.path.get().rsplit_once(path::MAIN_SEPARATOR)
+            && let Some(file) = file.strip_suffix(".rs")
+            && file == old_name
         {
-            let mut new_path = prev_lint.path.with_file_name(new_name).into_os_string();
-            new_path.push(".rs");
-            if try_rename_file(prev_lint.path.as_ref(), new_path.as_ref()) {
+            let new_path = cx
+                .str_buf
+                .alloc_display(cx.arena, format_args!("{path}{}{new_name}.rs", path::MAIN_SEPARATOR));
+            if try_rename_file(prev_file.path.get(), new_path) {
                 rename_mod = true;
+                prev_file.path.set(new_path);
             }
-
-            prev_lint.module = cx.str_buf.with(|buf| {
-                buf.push_str(&prev_lint.module[..prev_lint.module.len() - old_name.len()]);
-                buf.push_str(new_name);
-                cx.arena.alloc_str(buf)
-            });
         }
-        e.insert(Lint::Active(prev_lint));
-
+        e.insert(prev_lint);
         rename_test_files(old_name, new_name, &create_ignored_prefixes(old_name, &data));
     } else {
         println!("Renamed `{old_name}` to `{new_name}`");
@@ -151,7 +160,7 @@ pub fn rename<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
             updater.update_file(e.path(), &mut update_fn);
         }
     }
-    generate_lint_files(UpdateMode::Change, &data);
+    data.gen_decls(UpdateMode::Change);
 
     println!("Renamed `{old_name}` to `{new_name}`");
     println!("All code referencing the old name has been updated");
@@ -161,22 +170,22 @@ pub fn rename<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version, old_nam
 
 /// Removes a lint's declaration and test files. Returns whether the module containing the
 /// lint was deleted.
-fn remove_lint_declaration(name: &str, lint: &ActiveLint<'_>, data: &LintData<'_>, updater: &mut FileUpdater) -> bool {
-    let delete_mod = if data.lints.iter().all(|(_, l)| {
-        if let Lint::Active(l) = l {
-            l.module != lint.module
-        } else {
-            true
-        }
-    }) {
-        delete_file_if_exists(lint.path.as_ref())
+fn remove_lint_declaration(
+    name: &str,
+    lint_file: &SourceFile<'_>,
+    lint_data: &ActiveLint<'_>,
+    data: &ParsedLints<'_>,
+    updater: &mut FileUpdater,
+) -> bool {
+    let delete_mod = if data.lints.iter().all(|(_, l)| l.name_sp.file != lint_file) {
+        delete_file_if_exists(lint_file.path.get())
     } else {
-        updater.update_file(&lint.path, &mut |_, src, dst| -> UpdateStatus {
-            let mut start = &src[..lint.declaration_range.start];
+        updater.update_file(lint_file.path.get(), &mut |_, src, dst| -> UpdateStatus {
+            let mut start = &src[..lint_data.decl_range.start as usize];
             if start.ends_with("\n\n") {
                 start = &start[..start.len() - 1];
             }
-            let mut end = &src[lint.declaration_range.end..];
+            let mut end = &src[lint_data.decl_range.end as usize..];
             if end.starts_with("\n\n") {
                 end = &end[1..];
             }
@@ -195,10 +204,10 @@ fn remove_lint_declaration(name: &str, lint: &ActiveLint<'_>, data: &LintData<'_
 ///
 /// This is needed because rustc doesn't allow a lint to be renamed to a lint that has
 /// also been renamed.
-fn update_rename_targets<'cx>(data: &mut LintData<'cx>, old_name: &str, new_name: LintName<'cx>) {
+fn update_rename_targets<'cx>(data: &mut ParsedLints<'cx>, old_name: &str, new_name: LintName<'cx>) {
     let old_name = LintName::new_clippy(old_name);
     for lint in data.lints.values_mut() {
-        if let Lint::Renamed(lint) = lint
+        if let LintData::Renamed(lint) = &mut lint.data
             && lint.new_name == old_name
         {
             lint.new_name = new_name;
@@ -207,7 +216,7 @@ fn update_rename_targets<'cx>(data: &mut LintData<'cx>, old_name: &str, new_name
 }
 
 /// Creates a list of prefixes to ignore when
-fn create_ignored_prefixes<'cx>(name: &str, data: &LintData<'cx>) -> Vec<&'cx str> {
+fn create_ignored_prefixes<'cx>(name: &str, data: &ParsedLints<'cx>) -> Vec<&'cx str> {
     data.lints
         .keys()
         .copied()
@@ -258,9 +267,9 @@ fn rename_test_files(old_name: &str, new_name: &str, ignored_prefixes: &[&str])
         old_buf.push(name);
         new_buf.extend([new_name.as_ref(), name.slice_encoded_bytes(old_name.len()..)]);
         if is_file {
-            try_rename_file(old_buf.as_ref(), new_buf.as_ref());
+            try_rename_file(&old_buf, &new_buf);
         } else {
-            try_rename_dir(old_buf.as_ref(), new_buf.as_ref());
+            try_rename_dir(&old_buf, &new_buf);
         }
         old_buf.truncate("tests/ui/".len());
         new_buf.truncate("tests/ui/".len());
@@ -275,7 +284,7 @@ fn rename_test_files(old_name: &str, new_name: &str, ignored_prefixes: &[&str])
     for (name, _) in &tests {
         old_buf.push(name);
         new_buf.extend([new_name.as_ref(), name.slice_encoded_bytes(old_name.len()..)]);
-        try_rename_dir(old_buf.as_ref(), new_buf.as_ref());
+        try_rename_dir(&old_buf, &new_buf);
         old_buf.truncate("tests/ui/".len());
         new_buf.truncate("tests/ui/".len());
     }
@@ -291,9 +300,9 @@ fn delete_test_files(lint: &str, ignored_prefixes: &[&str]) {
     for &(ref name, is_file) in &tests {
         buf.push(name);
         if is_file {
-            delete_file_if_exists(buf.as_ref());
+            delete_file_if_exists(&buf);
         } else {
-            delete_dir_if_exists(buf.as_ref());
+            delete_dir_if_exists(&buf);
         }
         buf.truncate("tests/ui/".len());
     }
@@ -305,7 +314,7 @@ fn delete_test_files(lint: &str, ignored_prefixes: &[&str]) {
     collect_ui_toml_test_names(lint, ignored_prefixes, &mut tests);
     for (name, _) in &tests {
         buf.push(name);
-        delete_dir_if_exists(buf.as_ref());
+        delete_dir_if_exists(&buf);
         buf.truncate("tests/ui/".len());
     }
 }
@@ -338,11 +347,9 @@ fn uplift_update_fn<'a>(
         let mut copy_pos = 0u32;
         let mut changed = false;
         let mut cursor = Cursor::new(src);
-        while let Some(ident) = cursor.find_any_ident() {
+        while let Some(ident) = cursor.find_capture_ident() {
             match cursor.get_text(ident) {
-                "mod"
-                    if remove_mod && cursor.match_all(&[cursor::Pat::Ident(old_name), cursor::Pat::Semi], &mut []) =>
-                {
+                "mod" if remove_mod && cursor.eat_ident(old_name) && cursor.eat_semi() => {
                     dst.push_str(&src[copy_pos as usize..ident.pos as usize]);
                     dst.push_str(new_name);
                     copy_pos = cursor.pos();
@@ -351,7 +358,7 @@ fn uplift_update_fn<'a>(
                     }
                     changed = true;
                 },
-                "clippy" if cursor.match_all(&[cursor::Pat::DoubleColon, cursor::Pat::Ident(old_name)], &mut []) => {
+                "clippy" if cursor.eat_double_colon() && cursor.eat_ident(old_name) => {
                     dst.push_str(&src[copy_pos as usize..ident.pos as usize]);
                     dst.push_str(new_name);
                     copy_pos = cursor.pos();
@@ -390,7 +397,9 @@ fn rename_update_fn<'a>(
                     match text {
                         // clippy::line_name or clippy::lint-name
                         "clippy" => {
-                            if cursor.match_all(&[cursor::Pat::DoubleColon, cursor::Pat::CaptureIdent], &mut captures)
+                            if cursor
+                                .match_all(&[cursor::Pat::DoubleColon, cursor::Pat::CaptureIdent], &mut captures)
+                                .is_ok()
                                 && cursor.get_text(captures[0]) == old_name
                             {
                                 dst.push_str(&src[copy_pos as usize..captures[0].pos as usize]);
@@ -401,8 +410,11 @@ fn rename_update_fn<'a>(
                         },
                         // mod lint_name
                         "mod" => {
-                            if rename_mod && let Some(pos) = cursor.match_ident(old_name) {
-                                dst.push_str(&src[copy_pos as usize..pos as usize]);
+                            if rename_mod
+                                && let Some(mod_name) = cursor.capture_ident()
+                                && cursor.get_text(mod_name) == old_name
+                            {
+                                dst.push_str(&src[copy_pos as usize..mod_name.pos as usize]);
                                 dst.push_str(new_name);
                                 copy_pos = cursor.pos();
                                 changed = true;
@@ -411,7 +423,7 @@ fn rename_update_fn<'a>(
                         // lint_name::
                         name if rename_mod && name == old_name => {
                             let name_end = cursor.pos();
-                            if cursor.match_pat(cursor::Pat::DoubleColon) {
+                            if cursor.eat_double_colon() {
                                 dst.push_str(&src[copy_pos as usize..match_start as usize]);
                                 dst.push_str(new_name);
                                 copy_pos = name_end;
@@ -450,7 +462,9 @@ fn rename_update_fn<'a>(
                 },
                 // ::lint_name
                 TokenKind::Colon
-                    if cursor.match_all(&[cursor::Pat::DoubleColon, cursor::Pat::CaptureIdent], &mut captures)
+                    if cursor
+                        .match_all(&[cursor::Pat::DoubleColon, cursor::Pat::CaptureIdent], &mut captures)
+                        .is_ok()
                         && cursor.get_text(captures[0]) == old_name =>
                 {
                     dst.push_str(&src[copy_pos as usize..captures[0].pos as usize]);
diff --git a/clippy_dev/src/fmt.rs b/clippy_dev/src/fmt.rs
index 781e37e6144e..77c53b11d03d 100644
--- a/clippy_dev/src/fmt.rs
+++ b/clippy_dev/src/fmt.rs
@@ -1,233 +1,13 @@
+use crate::generate::gen_sorted_lints_file;
+use crate::new_parse_cx;
 use crate::utils::{
-    ErrAction, FileUpdater, UpdateMode, UpdateStatus, expect_action, run_with_output, split_args_for_threads,
+    ErrAction, FileUpdater, UpdateMode, UpdateStatus, VecBuf, expect_action, run_with_output, split_args_for_threads,
     walk_dir_no_dot_or_target,
 };
-use itertools::Itertools;
-use rustc_lexer::{FrontmatterAllowed, TokenKind, tokenize};
 use std::fmt::Write;
-use std::fs;
-use std::io::{self, Read};
-use std::ops::ControlFlow;
-use std::path::PathBuf;
+use std::io::Read;
 use std::process::{self, Command, Stdio};
 
-pub enum Error {
-    Io(io::Error),
-    Parse(PathBuf, usize, String),
-    CheckFailed,
-}
-
-impl From<io::Error> for Error {
-    fn from(error: io::Error) -> Self {
-        Self::Io(error)
-    }
-}
-
-impl Error {
-    fn display(&self) {
-        match self {
-            Self::CheckFailed => {
-                eprintln!("Formatting check failed!\nRun `cargo dev fmt` to update.");
-            },
-            Self::Io(err) => {
-                eprintln!("error: {err}");
-            },
-            Self::Parse(path, line, msg) => {
-                eprintln!("error parsing `{}:{line}`: {msg}", path.display());
-            },
-        }
-    }
-}
-
-struct ClippyConf<'a> {
-    name: &'a str,
-    attrs: &'a str,
-    lints: Vec<&'a str>,
-    field: &'a str,
-}
-
-fn offset_to_line(text: &str, offset: usize) -> usize {
-    match text.split('\n').try_fold((1usize, 0usize), |(line, pos), s| {
-        let pos = pos + s.len() + 1;
-        if pos > offset {
-            ControlFlow::Break(line)
-        } else {
-            ControlFlow::Continue((line + 1, pos))
-        }
-    }) {
-        ControlFlow::Break(x) | ControlFlow::Continue((x, _)) => x,
-    }
-}
-
-/// Formats the configuration list in `clippy_config/src/conf.rs`
-#[expect(clippy::too_many_lines)]
-fn fmt_conf(check: bool) -> Result<(), Error> {
-    #[derive(Clone, Copy)]
-    enum State {
-        Start,
-        Docs,
-        Pound,
-        OpenBracket,
-        Attr(u32),
-        Lints,
-        EndLints,
-        Field,
-    }
-
-    let path = "clippy_config/src/conf.rs";
-    let text = fs::read_to_string(path)?;
-
-    let (pre, conf) = text
-        .split_once("define_Conf! {\n")
-        .expect("can't find config definition");
-    let (conf, post) = conf.split_once("\n}\n").expect("can't find config definition");
-    let conf_offset = pre.len() + 15;
-
-    let mut pos = 0u32;
-    let mut attrs_start = 0;
-    let mut attrs_end = 0;
-    let mut field_start = 0;
-    let mut lints = Vec::new();
-    let mut name = "";
-    let mut fields = Vec::new();
-    let mut state = State::Start;
-
-    for (i, t) in tokenize(conf, FrontmatterAllowed::No)
-        .map(|x| {
-            let start = pos;
-            pos += x.len;
-            (start as usize, x)
-        })
-        .filter(|(_, t)| !matches!(t.kind, TokenKind::Whitespace))
-    {
-        match (state, t.kind) {
-            (State::Start, TokenKind::LineComment { doc_style: Some(_) }) => {
-                attrs_start = i;
-                attrs_end = i + t.len as usize;
-                state = State::Docs;
-            },
-            (State::Start, TokenKind::Pound) => {
-                attrs_start = i;
-                attrs_end = i;
-                state = State::Pound;
-            },
-            (State::Docs, TokenKind::LineComment { doc_style: Some(_) }) => attrs_end = i + t.len as usize,
-            (State::Docs, TokenKind::Pound) => state = State::Pound,
-            (State::Pound, TokenKind::OpenBracket) => state = State::OpenBracket,
-            (State::OpenBracket, TokenKind::Ident) => {
-                state = if conf[i..i + t.len as usize] == *"lints" {
-                    State::Lints
-                } else {
-                    State::Attr(0)
-                };
-            },
-            (State::Attr(0), TokenKind::CloseBracket) => {
-                attrs_end = i + 1;
-                state = State::Docs;
-            },
-            (State::Attr(x), TokenKind::OpenParen | TokenKind::OpenBracket | TokenKind::OpenBrace) => {
-                state = State::Attr(x + 1);
-            },
-            (State::Attr(x), TokenKind::CloseParen | TokenKind::CloseBracket | TokenKind::CloseBrace) => {
-                state = State::Attr(x - 1);
-            },
-            (State::Lints, TokenKind::Ident) => lints.push(&conf[i..i + t.len as usize]),
-            (State::Lints, TokenKind::CloseBracket) => state = State::EndLints,
-            (State::EndLints | State::Docs, TokenKind::Ident) => {
-                field_start = i;
-                name = &conf[i..i + t.len as usize];
-                state = State::Field;
-            },
-            (State::Field, TokenKind::LineComment { doc_style: Some(_) }) => {
-                #[expect(clippy::drain_collect)]
-                fields.push(ClippyConf {
-                    name,
-                    attrs: &conf[attrs_start..attrs_end],
-                    lints: lints.drain(..).collect(),
-                    field: conf[field_start..i].trim_end(),
-                });
-                attrs_start = i;
-                attrs_end = i + t.len as usize;
-                state = State::Docs;
-            },
-            (State::Field, TokenKind::Pound) => {
-                #[expect(clippy::drain_collect)]
-                fields.push(ClippyConf {
-                    name,
-                    attrs: &conf[attrs_start..attrs_end],
-                    lints: lints.drain(..).collect(),
-                    field: conf[field_start..i].trim_end(),
-                });
-                attrs_start = i;
-                attrs_end = i;
-                state = State::Pound;
-            },
-            (State::Field | State::Attr(_), _)
-            | (State::Lints, TokenKind::Comma | TokenKind::OpenParen | TokenKind::CloseParen) => {},
-            _ => {
-                return Err(Error::Parse(
-                    PathBuf::from(path),
-                    offset_to_line(&text, conf_offset + i),
-                    format!("unexpected token `{}`", &conf[i..i + t.len as usize]),
-                ));
-            },
-        }
-    }
-
-    if !matches!(state, State::Field) {
-        return Err(Error::Parse(
-            PathBuf::from(path),
-            offset_to_line(&text, conf_offset + conf.len()),
-            "incomplete field".into(),
-        ));
-    }
-    fields.push(ClippyConf {
-        name,
-        attrs: &conf[attrs_start..attrs_end],
-        lints,
-        field: conf[field_start..].trim_end(),
-    });
-
-    for field in &mut fields {
-        field.lints.sort_unstable();
-    }
-    fields.sort_by_key(|x| x.name);
-
-    let new_text = format!(
-        "{pre}define_Conf! {{\n{}}}\n{post}",
-        fields.iter().format_with("", |field, f| {
-            if field.lints.is_empty() {
-                f(&format_args!("    {}\n    {}\n", field.attrs, field.field))
-            } else if field.lints.iter().map(|x| x.len() + 2).sum::<usize>() < 120 - 14 {
-                f(&format_args!(
-                    "    {}\n    #[lints({})]\n    {}\n",
-                    field.attrs,
-                    field.lints.iter().join(", "),
-                    field.field,
-                ))
-            } else {
-                f(&format_args!(
-                    "    {}\n    #[lints({}\n    )]\n    {}\n",
-                    field.attrs,
-                    field
-                        .lints
-                        .iter()
-                        .format_with("", |x, f| f(&format_args!("\n        {x},"))),
-                    field.field,
-                ))
-            }
-        })
-    );
-
-    if text != new_text {
-        if check {
-            return Err(Error::CheckFailed);
-        }
-        fs::write(path, new_text)?;
-    }
-    Ok(())
-}
-
 /// Format the symbols list
 fn fmt_syms(update_mode: UpdateMode) {
     FileUpdater::default().update_file_checked(
@@ -326,10 +106,45 @@ fn run_rustfmt(update_mode: UpdateMode) {
 
 // the "main" function of cargo dev fmt
 pub fn run(update_mode: UpdateMode) {
-    run_rustfmt(update_mode);
     fmt_syms(update_mode);
-    if let Err(e) = fmt_conf(update_mode.is_check()) {
-        e.display();
-        process::exit(1);
-    }
+    new_parse_cx(|cx| {
+        let mut lint_data = cx.parse_lint_decls();
+        let mut conf_data = cx.parse_conf_mac();
+        cx.dcx.exit_on_err();
+
+        let mut updater = FileUpdater::default();
+
+        #[expect(clippy::mutable_key_type)]
+        let mut lints = lint_data.mk_file_to_lint_decl_map();
+        let mut ranges = VecBuf::with_capacity(256);
+        for passes in lint_data.iter_passes_by_file_mut() {
+            let file = passes[0].decl_sp.file;
+            let mut lints = lints.remove(file);
+            let lints = lints.as_deref_mut().unwrap_or_default();
+            updater.update_loaded_file_checked("cargo dev fmt", update_mode, file, &mut |_, src, dst| {
+                gen_sorted_lints_file(src, dst, lints, passes, &mut ranges);
+                UpdateStatus::from_changed(src != dst)
+            });
+        }
+        for (&file, lints) in &mut lints {
+            updater.update_loaded_file_checked("cargo dev fmt", update_mode, file, &mut |_, src, dst| {
+                gen_sorted_lints_file(src, dst, lints, &mut [], &mut ranges);
+                UpdateStatus::from_changed(src != dst)
+            });
+        }
+
+        updater.update_loaded_file_checked(
+            "cargo dev fmt",
+            update_mode,
+            conf_data.decl_sp.file,
+            &mut |_, src, dst| {
+                dst.push_str(&src[..conf_data.decl_sp.range.start as usize]);
+                conf_data.gen_mac(src, dst);
+                dst.push_str(&src[conf_data.decl_sp.range.end as usize..]);
+                UpdateStatus::from_changed(src != dst)
+            },
+        );
+    });
+
+    run_rustfmt(update_mode);
 }
diff --git a/clippy_dev/src/generate.rs b/clippy_dev/src/generate.rs
new file mode 100644
index 000000000000..3f42fcfbc4ae
--- /dev/null
+++ b/clippy_dev/src/generate.rs
@@ -0,0 +1,342 @@
+use crate::parse::cursor::Cursor;
+use crate::parse::{ConfDef, LintData, LintPass, ParsedLints};
+use crate::utils::{FileUpdater, UpdateMode, UpdateStatus, VecBuf, slice_groups, update_text_region_fn};
+use core::range::Range;
+use itertools::Itertools;
+use std::collections::HashSet;
+use std::fmt::Write;
+use std::path::{self, Path};
+
+const GENERATED_FILE_COMMENT: &str = "// This file was generated by `cargo dev update_lints`.\n\
+     // Use that command to update this file and do not edit by hand.\n\
+     // Manual edits will be overwritten.\n\n";
+
+const DOCS_LINK: &str = "https://rust-lang.github.io/rust-clippy/master/index.html";
+
+impl ParsedLints<'_> {
+    #[expect(clippy::too_many_lines)]
+    pub fn gen_decls(&self, update_mode: UpdateMode) {
+        let mut updater = FileUpdater::default();
+
+        let mut lints: Vec<_> = self.lints.iter().map(|(&x, y)| (x, y)).collect();
+        lints.sort_by_key(|&(x, _)| x);
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "CHANGELOG.md",
+            &mut update_text_region_fn(
+                "<!-- begin autogenerated links to lint list -->\n",
+                "<!-- end autogenerated links to lint list -->",
+                |dst| {
+                    for &(lint, _) in &lints {
+                        writeln!(dst, "[`{lint}`]: {DOCS_LINK}#{lint}").unwrap();
+                    }
+                },
+            ),
+        );
+
+        let mut active = Vec::with_capacity(lints.len());
+        let mut deprecated = Vec::with_capacity(lints.len() / 8);
+        let mut renamed = Vec::with_capacity(lints.len() / 8);
+        for &(name, lint) in &lints {
+            match &lint.data {
+                LintData::Active(_) => active.push((name, lint.name_sp.file.path_as_krate_mod())),
+                LintData::Deprecated(lint) => deprecated.push((name, lint)),
+                LintData::Renamed(lint) => renamed.push((name, lint)),
+            }
+        }
+        active.sort_by_key(|&(_, path)| path);
+
+        // Round to avoid updating the readme every time a lint is added/deprecated.
+        let lint_count = active.len() / 50 * 50;
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "README.md",
+            &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
+                write!(dst, "{lint_count}").unwrap();
+            }),
+        );
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "book/src/README.md",
+            &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
+                write!(dst, "{lint_count}").unwrap();
+            }),
+        );
+
+        updater.update_loaded_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            self.deprecated_file,
+            &mut |_, src, dst| {
+                let mut cursor = Cursor::new(src);
+                assert!(
+                    cursor.find_ident("declare_with_version") && cursor.find_ident("declare_with_version"),
+                    "error reading deprecated lints"
+                );
+                dst.push_str(&src[..cursor.pos() as usize]);
+                dst.push_str("! { DEPRECATED(DEPRECATED_VERSION) = [\n");
+                for &(name, data) in &deprecated {
+                    write!(
+                        dst,
+                        "    #[clippy::version = \"{}\"]\n    (\"clippy::{name}\", \"{}\"),\n",
+                        data.version, data.reason,
+                    )
+                    .unwrap();
+                }
+                dst.push_str(
+                    "]}\n\n\
+                        #[rustfmt::skip]\n\
+                        declare_with_version! { RENAMED(RENAMED_VERSION) = [\n\
+                    ",
+                );
+                for &(name, data) in &renamed {
+                    write!(
+                        dst,
+                        "    #[clippy::version = \"{}\"]\n    (\"clippy::{name}\", \"{}\"),\n",
+                        data.version, data.new_name,
+                    )
+                    .unwrap();
+                }
+                dst.push_str("]}\n");
+                UpdateStatus::from_changed(src != dst)
+            },
+        );
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "tests/ui/deprecated.rs",
+            &mut |_, src, dst| {
+                dst.push_str(GENERATED_FILE_COMMENT);
+                for &(lint, _) in &deprecated {
+                    writeln!(dst, "#![warn(clippy::{lint})] //~ ERROR: lint `clippy::{lint}`").unwrap();
+                }
+                dst.push_str("\nfn main() {}\n");
+                UpdateStatus::from_changed(src != dst)
+            },
+        );
+        updater.update_file_checked(
+            "cargo dev update_lints",
+            update_mode,
+            "tests/ui/rename.rs",
+            &mut move |_, src, dst| {
+                let mut seen_lints = HashSet::new();
+                dst.push_str(GENERATED_FILE_COMMENT);
+                dst.push_str("#![allow(clippy::duplicated_attributes)]\n");
+                for &(_, lint) in &renamed {
+                    if seen_lints.insert(lint.new_name) {
+                        writeln!(dst, "#![allow({})]", lint.new_name).unwrap();
+                    }
+                }
+                for &(lint, _) in &renamed {
+                    writeln!(dst, "#![warn(clippy::{lint})] //~ ERROR: lint `clippy::{lint}`").unwrap();
+                }
+                dst.push_str("\nfn main() {}\n");
+                UpdateStatus::from_changed(src != dst)
+            },
+        );
+
+        for lints in slice_groups(&active, |(_, (head, _)), tail| {
+            tail.iter().take_while(|(_, (x, _))| head == x).count()
+        }) {
+            let (_, (krate, _)) = lints[0];
+            updater.update_file_checked(
+                "cargo dev update_lints",
+                update_mode,
+                Path::new(krate).join("src/lib.rs"),
+                &mut update_text_region_fn(
+                    "// begin lints modules, do not remove this comment, it's used in `update_lints`\n",
+                    "// end lints modules, do not remove this comment, it's used in `update_lints`",
+                    |dst| {
+                        let mut prev = "";
+                        for &(_, (_, mod_path)) in lints {
+                            let module = mod_path.split_once(path::MAIN_SEPARATOR).map_or(mod_path, |(x, _)| x);
+                            if module != prev {
+                                writeln!(dst, "mod {module};").unwrap();
+                                prev = module;
+                            }
+                        }
+                    },
+                ),
+            );
+            updater.update_file_checked(
+                "cargo dev update_lints",
+                update_mode,
+                Path::new(krate).join("src/declared_lints.rs"),
+                &mut |_, src, dst| {
+                    dst.push_str(GENERATED_FILE_COMMENT);
+                    dst.push_str("pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[\n");
+                    let mut buf = String::new();
+                    for &(name, (_, mod_path)) in lints {
+                        dst.push_str("    crate::");
+                        for part in mod_path.split(path::MAIN_SEPARATOR) {
+                            dst.push_str(part);
+                            dst.push_str("::");
+                        }
+                        buf.clear();
+                        buf.push_str(name);
+                        buf.make_ascii_uppercase();
+                        let _ = writeln!(dst, "{buf}_INFO,");
+                    }
+                    dst.push_str("];\n");
+                    UpdateStatus::from_changed(src != dst)
+                },
+            );
+        }
+    }
+}
+
+impl LintPass<'_> {
+    pub fn gen_mac(&self, dst: &mut String) {
+        let mut line_start = dst.len();
+        dst.extend([self.mac.name(), "!("]);
+        let has_docs = write_comment_lines(self.docs, "\n    ", dst);
+        let (list_indent, list_multi_end, end) = if has_docs {
+            dst.push_str("\n    ");
+            line_start = dst.len() - 4;
+            ("        ", "\n    ", "]\n);")
+        } else {
+            ("    ", "\n", "]);")
+        };
+        dst.push_str(self.name);
+        if let Some(lt) = self.lt {
+            dst.extend(["<", lt, ">"]);
+        }
+        dst.push_str(" => [");
+        let fmt = write_list(
+            self.lints.iter().copied(),
+            80usize.saturating_sub(dst.len() - line_start),
+            list_indent,
+            dst,
+        );
+        if matches!(fmt, ListFmt::MultiLine) {
+            dst.push_str(list_multi_end);
+        }
+        dst.push_str(end);
+    }
+}
+
+impl ConfDef<'_> {
+    pub fn gen_mac(&mut self, src: &str, dst: &mut String) {
+        self.opts.sort_unstable_by_key(|o| o.name);
+        dst.push_str("define_Conf! {");
+        for opt in &mut self.opts {
+            let pre_lints = src[opt.decl_range.start as usize..opt.lints_range.start as usize].trim_end();
+            if !pre_lints.is_empty() {
+                dst.push_str("\n    ");
+                dst.push_str(pre_lints);
+            }
+            let pre_name_text = if opt.lints.is_empty() {
+                "\n    "
+            } else {
+                opt.lints.sort_unstable();
+                dst.push_str("\n    #[lints(");
+                let fmt = write_list(opt.lints.iter().copied(), 80 - 14, "        ", dst);
+                match fmt {
+                    ListFmt::SingleLine => ")]\n    ",
+                    ListFmt::MultiLine => "\n    )]\n    ",
+                }
+            };
+            dst.push_str(pre_name_text);
+            dst.push_str(src[opt.lints_range.end as usize..opt.decl_range.end as usize].trim());
+            dst.push(',');
+        }
+        dst.push_str("\n}");
+    }
+}
+
+fn write_comment_lines(s: &str, prefix: &str, dst: &mut String) -> bool {
+    let mut has_doc = false;
+    for line in s.split('\n') {
+        let line = line.trim_start();
+        if !line.is_empty() {
+            has_doc = true;
+            dst.extend([prefix, line]);
+        }
+    }
+    has_doc
+}
+
+#[derive(Clone, Copy)]
+enum ListFmt {
+    SingleLine,
+    MultiLine,
+}
+
+fn write_list<'a>(
+    items: impl Iterator<Item = &'a str> + Clone,
+    single_line_limit: usize,
+    indent: &str,
+    dst: &mut String,
+) -> ListFmt {
+    let len = items.clone().map(str::len).sum::<usize>();
+    if len > single_line_limit {
+        for item in items {
+            dst.extend(["\n", indent, item, ","]);
+        }
+        ListFmt::MultiLine
+    } else {
+        let _ = write!(dst, "{}", items.format(", "));
+        ListFmt::SingleLine
+    }
+}
+
+/// Generates the contents of a lint's source file with all the lint and lint pass
+/// declarations sorted.
+pub fn gen_sorted_lints_file(
+    src: &str,
+    dst: &mut String,
+    lints: &mut [(&str, Range<u32>)],
+    passes: &mut [LintPass<'_>],
+    ranges: &mut VecBuf<Range<u32>>,
+) {
+    ranges.with(|ranges| {
+        ranges.extend(lints.iter().map(|&(_, x)| x));
+        ranges.extend(passes.iter().map(|x| x.decl_sp.range));
+        ranges.sort_unstable_by_key(|x| x.start);
+
+        lints.sort_unstable_by_key(|&(x, _)| x);
+        passes.sort_by_key(|x| x.name);
+
+        let mut ranges = ranges.iter();
+        let pos = if let Some(range) = ranges.next() {
+            dst.push_str(&src[..range.start as usize]);
+            for &(_, range) in &*lints {
+                dst.push_str(&src[range.start as usize..range.end as usize]);
+                dst.push_str("\n\n");
+            }
+            for pass in passes {
+                pass.lints.sort_unstable();
+                pass.gen_mac(dst);
+                dst.push_str("\n\n");
+            }
+            range.end
+        } else {
+            dst.push_str(src);
+            return;
+        };
+
+        let pos = ranges.fold(pos, |start, range| {
+            let s = &src[start as usize..range.start as usize];
+            dst.push_str(if s.trim_start().is_empty() {
+                // Only whitespace between this and the previous item. No need to keep that.
+                ""
+            } else if src[..pos as usize].ends_with("\n\n")
+                && let Some(s) = s.strip_prefix("\n\n")
+            {
+                // Empty line before and after. Remove one of them.
+                s
+            } else {
+                // Remove only full lines unless something is in the way.
+                s.strip_prefix('\n').unwrap_or(s)
+            });
+            range.end
+        });
+
+        // Since we always generate an empty line at the end, make sure to always skip it.
+        let s = &src[pos as usize..];
+        dst.push_str(s.strip_prefix('\n').map_or(s, |s| s.strip_prefix('\n').unwrap_or(s)));
+    });
+}
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index cff51d34c30e..ad3aa19dcd07 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -1,6 +1,9 @@
 #![feature(
+    bool_to_result,
     exit_status_error,
+    hash_set_entry,
     if_let_guard,
+    macro_metavar_expr_concat,
     new_range,
     new_range_api,
     os_str_slice,
@@ -16,13 +19,14 @@
     unused_lifetimes,
     unused_qualifications
 )]
-#![allow(clippy::missing_panics_doc)]
+#![allow(clippy::case_sensitive_file_extension_comparisons, clippy::missing_panics_doc)]
 
 extern crate rustc_arena;
 extern crate rustc_data_structures;
 #[expect(unused_extern_crates, reason = "required to link to rustc crates")]
 extern crate rustc_driver;
 extern crate rustc_lexer;
+extern crate termize;
 
 pub mod dogfood;
 pub mod edit_lints;
@@ -33,10 +37,12 @@ pub mod release;
 pub mod serve;
 pub mod setup;
 pub mod sync;
-pub mod update_lints;
 
+mod diag;
+mod generate;
 mod parse;
 mod utils;
 
+pub use self::diag::DiagCx;
 pub use self::parse::{ParseCx, new_parse_cx};
-pub use self::utils::{ClippyInfo, UpdateMode};
+pub use self::utils::{ClippyInfo, SourceFile, Span, UpdateMode};
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 8dc2290df8e4..9e0f2fa14cb0 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -5,7 +5,6 @@
 use clap::{Args, Parser, Subcommand};
 use clippy_dev::{
     ClippyInfo, UpdateMode, dogfood, edit_lints, fmt, lint, new_lint, new_parse_cx, release, serve, setup, sync,
-    update_lints,
 };
 use std::env;
 
@@ -27,7 +26,11 @@ fn main() {
             allow_no_vcs,
         } => dogfood::dogfood(fix, allow_dirty, allow_staged, allow_no_vcs),
         DevCommand::Fmt { check } => fmt::run(UpdateMode::from_check(check)),
-        DevCommand::UpdateLints { check } => new_parse_cx(|cx| update_lints::update(cx, UpdateMode::from_check(check))),
+        DevCommand::UpdateLints { check } => new_parse_cx(|cx| {
+            let data = cx.parse_lint_decls();
+            cx.dcx.exit_on_err();
+            data.gen_decls(UpdateMode::from_check(check));
+        }),
         DevCommand::NewLint {
             pass,
             name,
@@ -35,7 +38,11 @@ fn main() {
             r#type,
             msrv,
         } => match new_lint::create(clippy.version, pass, &name, &category, r#type.as_deref(), msrv) {
-            Ok(()) => new_parse_cx(|cx| update_lints::update(cx, UpdateMode::Change)),
+            Ok(()) => new_parse_cx(|cx| {
+                let data = cx.parse_lint_decls();
+                cx.dcx.exit_on_err();
+                data.gen_decls(UpdateMode::Change);
+            }),
             Err(e) => eprintln!("Unable to create lint: {e}"),
         },
         DevCommand::Setup(SetupCommand { subcommand }) => match subcommand {
diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index 2abe471bed2b..04153c9679d3 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -524,12 +524,18 @@ fn parse_mod_file(path: &Path, contents: &str) -> (&'static str, usize) {
     let mut decl_end = None;
     let mut cursor = Cursor::new(contents);
     let mut captures = [Capture::EMPTY];
-    while let Some(name) = cursor.find_any_ident() {
+    while let Some(name) = cursor.find_capture_ident() {
         match cursor.get_text(name) {
-            "declare_clippy_lint" if cursor.match_all(&[Bang, OpenBrace], &mut []) && cursor.find_pat(CloseBrace) => {
+            "declare_clippy_lint"
+                if cursor.match_all(&[Bang, OpenBrace], &mut []).is_ok() && cursor.find_close_brace() =>
+            {
                 decl_end = Some(cursor.pos());
             },
-            "impl" if cursor.match_all(&[Lt, Lifetime, Gt, CaptureIdent], &mut captures) => {
+            "impl"
+                if cursor
+                    .match_all(&[Lt, Lifetime, Gt, CaptureIdent], &mut captures)
+                    .is_ok() =>
+            {
                 match cursor.get_text(captures[0]) {
                     "LateLintPass" => context = Some("LateContext"),
                     "EarlyLintPass" => context = Some("EarlyContext"),
diff --git a/clippy_dev/src/parse.rs b/clippy_dev/src/parse.rs
index ffb50784a9a7..9692c6a7d2ba 100644
--- a/clippy_dev/src/parse.rs
+++ b/clippy_dev/src/parse.rs
@@ -1,87 +1,37 @@
 pub mod cursor;
 
-use self::cursor::{Capture, Cursor};
-use crate::utils::{ErrAction, File, Scoped, expect_action, walk_dir_no_dot_or_target};
-use core::fmt::{self, Display, Write as _};
+use self::cursor::{Capture, Cursor, IdentPat};
+use crate::utils::{ErrAction, Scoped, StrBuf, VecBuf, expect_action, slice_groups_mut, walk_dir_no_dot_or_target};
+use crate::{DiagCx, SourceFile, Span};
+use core::fmt::{self, Display};
 use core::range::Range;
-use rustc_arena::DroplessArena;
+use rustc_arena::{DroplessArena, TypedArena};
 use rustc_data_structures::fx::FxHashMap;
-use std::fs;
-use std::path::{self, Path, PathBuf};
-use std::str::pattern::Pattern;
+use std::collections::hash_map::{Entry, VacantEntry};
+use std::{fs, path};
 
 pub struct ParseCxImpl<'cx> {
     pub arena: &'cx DroplessArena,
+    pub source_files: &'cx TypedArena<SourceFile<'cx>>,
     pub str_buf: StrBuf,
+    pub str_list_buf: VecBuf<&'cx str>,
+    pub dcx: DiagCx,
 }
 pub type ParseCx<'cx> = &'cx mut ParseCxImpl<'cx>;
 
 /// Calls the given function inside a newly created parsing context.
 pub fn new_parse_cx<'env, T>(f: impl for<'cx> FnOnce(&'cx mut Scoped<'cx, 'env, ParseCxImpl<'cx>>) -> T) -> T {
     let arena = DroplessArena::default();
+    let source_files = TypedArena::default();
     f(&mut Scoped::new(ParseCxImpl {
         arena: &arena,
+        source_files: &source_files,
         str_buf: StrBuf::with_capacity(128),
+        str_list_buf: VecBuf::with_capacity(128),
+        dcx: DiagCx::default(),
     }))
 }
 
-/// A string used as a temporary buffer used to avoid allocating for short lived strings.
-pub struct StrBuf(String);
-impl StrBuf {
-    /// Creates a new buffer with the specified initial capacity.
-    pub fn with_capacity(cap: usize) -> Self {
-        Self(String::with_capacity(cap))
-    }
-
-    /// Allocates the result of formatting the given value onto the arena.
-    pub fn alloc_display<'cx>(&mut self, arena: &'cx DroplessArena, value: impl Display) -> &'cx str {
-        self.0.clear();
-        write!(self.0, "{value}").expect("`Display` impl returned an error");
-        arena.alloc_str(&self.0)
-    }
-
-    /// Allocates the string onto the arena with all ascii characters converted to
-    /// lowercase.
-    pub fn alloc_ascii_lower<'cx>(&mut self, arena: &'cx DroplessArena, s: &str) -> &'cx str {
-        self.0.clear();
-        self.0.push_str(s);
-        self.0.make_ascii_lowercase();
-        arena.alloc_str(&self.0)
-    }
-
-    /// Allocates the result of replacing all instances the pattern with the given string
-    /// onto the arena.
-    pub fn alloc_replaced<'cx>(
-        &mut self,
-        arena: &'cx DroplessArena,
-        s: &str,
-        pat: impl Pattern,
-        replacement: &str,
-    ) -> &'cx str {
-        let mut parts = s.split(pat);
-        let Some(first) = parts.next() else {
-            return "";
-        };
-        self.0.clear();
-        self.0.push_str(first);
-        for part in parts {
-            self.0.push_str(replacement);
-            self.0.push_str(part);
-        }
-        if self.0.is_empty() {
-            ""
-        } else {
-            arena.alloc_str(&self.0)
-        }
-    }
-
-    /// Performs an operation with the freshly cleared buffer.
-    pub fn with<T>(&mut self, f: impl FnOnce(&mut String) -> T) -> T {
-        self.0.clear();
-        f(&mut self.0)
-    }
-}
-
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub enum LintTool {
     Rustc,
@@ -95,25 +45,29 @@ impl LintTool {
             Self::Clippy => "clippy::",
         }
     }
+
+    pub fn from_prefix(s: &str) -> Option<Self> {
+        (s == "clippy").then_some(Self::Clippy)
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct LintName<'cx> {
-    pub name: &'cx str,
     pub tool: LintTool,
+    pub name: &'cx str,
 }
 impl<'cx> LintName<'cx> {
     pub fn new_rustc(name: &'cx str) -> Self {
         Self {
-            name,
             tool: LintTool::Rustc,
+            name,
         }
     }
 
     pub fn new_clippy(name: &'cx str) -> Self {
         Self {
-            name,
             tool: LintTool::Clippy,
+            name,
         }
     }
 }
@@ -126,9 +80,7 @@ impl Display for LintName<'_> {
 
 pub struct ActiveLint<'cx> {
     pub group: &'cx str,
-    pub module: &'cx str,
-    pub path: PathBuf,
-    pub declaration_range: Range<usize>,
+    pub decl_range: Range<u32>,
 }
 
 pub struct DeprecatedLint<'cx> {
@@ -141,26 +93,198 @@ pub struct RenamedLint<'cx> {
     pub version: &'cx str,
 }
 
-pub enum Lint<'cx> {
+pub enum LintData<'cx> {
     Active(ActiveLint<'cx>),
     Deprecated(DeprecatedLint<'cx>),
     Renamed(RenamedLint<'cx>),
 }
 
-pub struct LintData<'cx> {
+pub struct Lint<'cx> {
+    pub name_sp: Span<'cx>,
+    pub data: LintData<'cx>,
+}
+
+#[derive(Clone, Copy)]
+pub enum LintPassMac {
+    Declare,
+    Impl,
+}
+impl LintPassMac {
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Declare => "declare_lint_pass",
+            Self::Impl => "impl_lint_pass",
+        }
+    }
+}
+
+pub struct LintPass<'cx> {
+    /// The raw text of the documentation comments. May include leading/trailing
+    /// whitespace and empty lines.
+    pub docs: &'cx str,
+    pub name: &'cx str,
+    pub lt: Option<&'cx str>,
+    pub mac: LintPassMac,
+    pub decl_sp: Span<'cx>,
+    pub lints: &'cx mut [&'cx str],
+}
+
+pub struct ParsedLints<'cx> {
     pub lints: FxHashMap<&'cx str, Lint<'cx>>,
+    pub lint_passes: Vec<LintPass<'cx>>,
+    pub deprecated_file: &'cx SourceFile<'cx>,
+}
+impl<'cx> ParsedLints<'cx> {
+    #[expect(clippy::mutable_key_type)]
+    pub fn mk_file_to_lint_decl_map(&self) -> FxHashMap<&'cx SourceFile<'cx>, Vec<(&'cx str, Range<u32>)>> {
+        #[expect(clippy::default_trait_access)]
+        let mut lints = FxHashMap::with_capacity_and_hasher(500, Default::default());
+        for (&name, lint) in &self.lints {
+            if let LintData::Active(lint_data) = &lint.data {
+                lints
+                    .entry(lint.name_sp.file)
+                    .or_insert_with(|| Vec::with_capacity(8))
+                    .push((name, lint_data.decl_range));
+            }
+        }
+        lints
+    }
+
+    pub fn iter_passes_by_file_mut<'s>(&'s mut self) -> impl Iterator<Item = &'s mut [LintPass<'cx>]> {
+        slice_groups_mut(&mut self.lint_passes, |head, tail| {
+            tail.iter().take_while(|&x| x.decl_sp.file == head.decl_sp.file).count()
+        })
+    }
+
+    #[track_caller]
+    fn get_vacant_lint<'a>(
+        &'a mut self,
+        dcx: &mut DiagCx,
+        name: &'cx str,
+        name_sp: Span<'cx>,
+    ) -> Option<VacantEntry<'a, &'cx str, Lint<'cx>>> {
+        match self.lints.entry(name) {
+            Entry::Vacant(e) => Some(e),
+            Entry::Occupied(e) => {
+                dcx.emit_duplicate_lint(name_sp, e.get().name_sp);
+                None
+            },
+        }
+    }
+}
+
+pub struct ConfOpt<'cx> {
+    pub name: &'cx str,
+    pub decl_range: Range<u32>,
+    pub lints: &'cx mut [&'cx str],
+    pub lints_range: Range<u32>,
+}
+
+pub struct ConfDef<'cx> {
+    pub decl_sp: Span<'cx>,
+    pub opts: Vec<ConfOpt<'cx>>,
 }
 
 impl<'cx> ParseCxImpl<'cx> {
+    pub fn parse_conf_mac(&mut self) -> ConfDef<'cx> {
+        #[allow(clippy::enum_glob_use)]
+        use cursor::Pat::*;
+
+        let file = &*self.source_files.alloc(SourceFile::load(self.str_buf.alloc_collect(
+            self.arena,
+            [
+                "clippy_config",
+                path::MAIN_SEPARATOR_STR,
+                "src",
+                path::MAIN_SEPARATOR_STR,
+                "conf.rs",
+            ],
+        )));
+
+        let mut data = ConfDef {
+            decl_sp: Span::new(file, 0..0),
+            opts: Vec::with_capacity(100),
+        };
+        let mut cursor = Cursor::new(&file.contents);
+        let mut captures = [Capture::EMPTY; 1];
+
+        if let Err(expected) = cursor
+            .find_mac_call("define_Conf")
+            .ok_or("`define_Conf!`")
+            .and_then(|name| {
+                data.decl_sp.range.start = name.pos;
+                cursor.eat_open_brace().ok_or("`{`")
+            })
+            .and_then(|()| {
+                cursor.eat_list(|cursor| {
+                    let docs = cursor.capture_doc_lines();
+                    let mut lints: &mut [_] = &mut [];
+                    let mut lints_range = None;
+                    let mut started = docs.len != 0;
+                    while let Some((attr_start, name)) = cursor.capture_opt_attr_start()? {
+                        started = true;
+                        if cursor.get_text(name) == "lints" {
+                            cursor
+                                .eat_open_paren()
+                                .ok_or("`(`")
+                                .and_then(|()| {
+                                    cursor.capture_list(&mut self.str_list_buf, self.arena, |cursor| {
+                                        Ok(cursor.capture_ident().map(|x| cursor.get_text(x)))
+                                    })
+                                })
+                                .and_then(|res| {
+                                    lints = res;
+                                    cursor.match_all(&[CloseParen, CloseBracket], &mut [])
+                                })?;
+                            lints_range = Some(attr_start..cursor.pos());
+                        } else {
+                            cursor.find_close_bracket().ok_or("`]`")?;
+                        }
+                    }
+                    match cursor.opt_match_all(&[CaptureIdent, Colon], &mut captures) {
+                        Ok(true) => {},
+                        Ok(false) if started => return Err("an identifier"),
+                        Ok(false) => return Ok(false),
+                        Err(e) => return Err(e),
+                    }
+                    cursor.find_eq().ok_or("`=`")?;
+                    cursor.eat_list_item();
+                    data.opts.push(ConfOpt {
+                        name: cursor.get_text(captures[0]),
+                        decl_range: docs.pos..cursor.pos(),
+                        lints,
+                        lints_range: lints_range.unwrap_or(captures[0].pos..captures[0].pos),
+                    });
+                    Ok(true)
+                })
+            })
+            .and_then(|()| cursor.eat_close_brace().ok_or("`}`"))
+        {
+            cursor.emit_unexpected(&mut self.dcx, file, expected);
+        }
+
+        data.decl_sp.range.end = cursor.pos();
+        data
+    }
+
     /// Finds and parses all lint declarations.
-    #[must_use]
-    pub fn parse_lint_decls(&mut self) -> LintData<'cx> {
-        let mut data = LintData {
+    pub fn parse_lint_decls(&mut self) -> ParsedLints<'cx> {
+        let mut data = ParsedLints {
             #[expect(clippy::default_trait_access)]
             lints: FxHashMap::with_capacity_and_hasher(1000, Default::default()),
+            lint_passes: Vec::with_capacity(400),
+            deprecated_file: self.source_files.alloc(SourceFile::load(self.str_buf.alloc_collect(
+                self.arena,
+                [
+                    "clippy_lints",
+                    path::MAIN_SEPARATOR_STR,
+                    "src",
+                    path::MAIN_SEPARATOR_STR,
+                    "deprecated_lints.rs",
+                ],
+            ))),
         };
 
-        let mut contents = String::new();
         for e in expect_action(fs::read_dir("."), ErrAction::Read, ".") {
             let e = expect_action(e, ErrAction::Read, ".");
 
@@ -179,192 +303,301 @@ impl<'cx> ParseCxImpl<'cx> {
             crate_path.push_str("src");
             for e in walk_dir_no_dot_or_target(&crate_path) {
                 let e = expect_action(e, ErrAction::Read, &crate_path);
-                if let Some(path) = e.path().to_str()
-                    && let Some(path) = path.strip_suffix(".rs")
-                    && let Some(path) = path.get(crate_path.len() + 1..)
+                if e.path().as_os_str().as_encoded_bytes().ends_with(b".rs")
+                    && let Some(file_path) = e.path().to_str()
+                    && file_path != data.deprecated_file.path.get()
                 {
-                    let module = if path == "lib" {
-                        ""
-                    } else {
-                        let path = path
-                            .strip_suffix("mod")
-                            .and_then(|x| x.strip_suffix(path::MAIN_SEPARATOR))
-                            .unwrap_or(path);
-                        self.str_buf
-                            .alloc_replaced(self.arena, path, path::MAIN_SEPARATOR, "::")
-                    };
-                    self.parse_clippy_lint_decls(
-                        e.path(),
-                        File::open_read_to_cleared_string(e.path(), &mut contents),
-                        module,
-                        &mut data,
-                    );
+                    let file = self
+                        .source_files
+                        .alloc(SourceFile::load(self.arena.alloc_str(file_path)));
+                    self.parse_lint_src_file(&mut data, file);
                 }
             }
         }
 
-        self.read_deprecated_lints(&mut data);
+        self.parse_deprecated_lints(&mut data);
         data
     }
 
     /// Parse a source file looking for `declare_clippy_lint` macro invocations.
-    fn parse_clippy_lint_decls(&mut self, path: &Path, contents: &str, module: &'cx str, data: &mut LintData<'cx>) {
+    fn parse_lint_src_file(&mut self, data: &mut ParsedLints<'cx>, file: &'cx SourceFile<'cx>) {
         #[allow(clippy::enum_glob_use)]
         use cursor::Pat::*;
-        #[rustfmt::skip]
-        static DECL_TOKENS: &[cursor::Pat<'_>] = &[
-            // !{ /// docs
-            Bang, OpenBrace, AnyComment,
-            // #[clippy::version = "version"]
-            Pound, OpenBracket, Ident("clippy"), DoubleColon, Ident("version"), Eq, LitStr, CloseBracket,
-            // pub NAME, GROUP,
-            Ident("pub"), CaptureIdent, Comma, AnyComment, CaptureIdent, Comma,
-        ];
 
-        let mut cursor = Cursor::new(contents);
-        let mut captures = [Capture::EMPTY; 2];
-        while let Some(start) = cursor.find_ident("declare_clippy_lint") {
-            if cursor.match_all(DECL_TOKENS, &mut captures) && cursor.find_pat(CloseBrace) {
-                assert!(
-                    data.lints
-                        .insert(
-                            self.str_buf.alloc_ascii_lower(self.arena, cursor.get_text(captures[0])),
-                            Lint::Active(ActiveLint {
-                                group: self.arena.alloc_str(cursor.get_text(captures[1])),
-                                module,
-                                path: path.into(),
-                                declaration_range: start as usize..cursor.pos() as usize,
+        let mut cursor = Cursor::new(&file.contents);
+        let mut captures = [Capture::EMPTY; 3];
+        while let Some(mac_name) = cursor.find_capture_ident() {
+            if !cursor.eat_bang() {
+                continue;
+            }
+            match cursor.get_text(mac_name) {
+                "declare_clippy_lint" => {
+                    #[rustfmt::skip]
+                    static DECL_START: &[cursor::Pat] = &[
+                        // { /// docs
+                        OpenBrace, AnyComments,
+                        // #[clippy::version = "version"]
+                        Pound, OpenBracket, Ident(IdentPat::clippy), DoubleColon,
+                        Ident(IdentPat::version), Eq, CaptureLitStr, CloseBracket,
+                        // pub NAME, GROUP, "desc",
+                        Ident(IdentPat::r#pub), CaptureIdent, Comma,
+                        AnyComments, CaptureIdent, Comma, AnyComments, LitStr,
+                    ];
+                    #[rustfmt::skip]
+                    static OPTION: &[cursor::Pat] = &[
+                        // @option = value
+                        AnyComments, At, AnyIdent, Eq, Lit,
+                    ];
+
+                    if let Err(expected) = cursor
+                        .match_all(DECL_START, &mut captures)
+                        .and_then(|()| {
+                            (!cursor.eat_comma()).ok_or(()).or_else(|()| {
+                                cursor.eat_list(|cursor| cursor.match_all(OPTION, &mut []).map(|()| true))
+                            })
+                        })
+                        .and_then(|()| cursor.eat_close_brace().ok_or("`}`"))
+                    {
+                        cursor.emit_unexpected(&mut self.dcx, file, expected);
+                    } else if let name = self.str_buf.alloc_ascii_lower(self.arena, cursor.get_text(captures[1]))
+                        && let name_sp = captures[1].mk_sp(file)
+                        && let Some(e) = data.get_vacant_lint(&mut self.dcx, name, name_sp)
+                    {
+                        let _ = self.parse_version(cursor.get_text(captures[0]), captures[0].mk_sp(file));
+                        e.insert(Lint {
+                            name_sp,
+                            data: LintData::Active(ActiveLint {
+                                group: cursor.get_text(captures[2]),
+                                decl_range: mac_name.pos..cursor.pos(),
                             }),
-                        )
-                        .is_none()
-                );
+                        });
+                    }
+                },
+                mac @ ("declare_lint_pass" | "impl_lint_pass") => {
+                    let mut has_lt = false;
+                    let mut lints: &mut [_] = &mut [];
+                    if let Err(expected) = cursor
+                        .match_all(&[OpenParen, CaptureDocLines, CaptureIdent], &mut captures)
+                        .and_then(|()| cursor.opt_match_all(&[Lt, CaptureLifetime, Gt], &mut captures[2..]))
+                        .and_then(|res| {
+                            has_lt = res;
+                            cursor.match_all(&[FatArrow, OpenBracket], &mut [])
+                        })
+                        .and_then(|()| {
+                            cursor.capture_list(&mut self.str_list_buf, self.arena, |cursor| {
+                                cursor.capture_opt_path(&mut self.str_buf, self.arena)
+                            })
+                        })
+                        .and_then(|res| {
+                            lints = res;
+                            cursor.match_all(&[CloseBracket, CloseParen, Semi], &mut [])
+                        })
+                    {
+                        cursor.emit_unexpected(&mut self.dcx, file, expected);
+                    } else {
+                        data.lint_passes.push(LintPass {
+                            docs: cursor.get_text(captures[0]),
+                            name: cursor.get_text(captures[1]),
+                            lt: has_lt.then(|| cursor.get_text(captures[2])),
+                            mac: if matches!(mac, "declare_lint_pass") {
+                                LintPassMac::Declare
+                            } else {
+                                LintPassMac::Impl
+                            },
+                            decl_sp: Span::new(file, mac_name.pos..cursor.pos()),
+                            lints,
+                        });
+                    }
+                },
+                _ => {},
             }
         }
     }
 
-    fn read_deprecated_lints(&mut self, data: &mut LintData<'cx>) {
+    fn parse_deprecated_lints(&mut self, data: &mut ParsedLints<'cx>) {
         #[allow(clippy::enum_glob_use)]
         use cursor::Pat::*;
+
         #[rustfmt::skip]
-        static DECL_TOKENS: &[cursor::Pat<'_>] = &[
+        static DECL_TOKENS: &[cursor::Pat] = &[
             // #[clippy::version = "version"]
-            Pound, OpenBracket, Ident("clippy"), DoubleColon, Ident("version"), Eq, CaptureLitStr, CloseBracket,
-            // ("first", "second"),
-            OpenParen, CaptureLitStr, Comma, CaptureLitStr, CloseParen, Comma,
+            Pound, OpenBracket, Ident(IdentPat::clippy), DoubleColon,
+            Ident(IdentPat::version), Eq, CaptureLitStr, CloseBracket,
+            // ("first", "second")
+            OpenParen, CaptureLitStr, Comma, CaptureLitStr, CloseParen,
         ];
         #[rustfmt::skip]
-        static DEPRECATED_TOKENS: &[cursor::Pat<'_>] = &[
+        static DEPRECATED_TOKENS: &[cursor::Pat] = &[
             // !{ DEPRECATED(DEPRECATED_VERSION) = [
-            Bang, OpenBrace, Ident("DEPRECATED"), OpenParen, Ident("DEPRECATED_VERSION"), CloseParen, Eq, OpenBracket,
+            Bang, OpenBrace, Ident(IdentPat::DEPRECATED), OpenParen,
+            Ident(IdentPat::DEPRECATED_VERSION), CloseParen, Eq, OpenBracket,
         ];
         #[rustfmt::skip]
-        static RENAMED_TOKENS: &[cursor::Pat<'_>] = &[
+        static RENAMED_TOKENS: &[cursor::Pat] = &[
             // !{ RENAMED(RENAMED_VERSION) = [
-            Bang, OpenBrace, Ident("RENAMED"), OpenParen, Ident("RENAMED_VERSION"), CloseParen, Eq, OpenBracket,
+            Bang, OpenBrace, Ident(IdentPat::RENAMED), OpenParen,
+            Ident(IdentPat::RENAMED_VERSION), CloseParen, Eq, OpenBracket,
         ];
 
-        let path = "clippy_lints/src/deprecated_lints.rs";
-        let mut contents = String::new();
-        File::open_read_to_cleared_string(path, &mut contents);
-
-        let mut cursor = Cursor::new(&contents);
+        let file = data.deprecated_file;
+        let mut cursor = Cursor::new(&file.contents);
         let mut captures = [Capture::EMPTY; 3];
 
-        // First instance is the macro definition.
-        assert!(
-            cursor.find_ident("declare_with_version").is_some(),
-            "error reading deprecated lints"
-        );
-
-        if cursor.find_ident("declare_with_version").is_some() && cursor.match_all(DEPRECATED_TOKENS, &mut []) {
-            while cursor.match_all(DECL_TOKENS, &mut captures) {
-                assert!(
-                    data.lints
-                        .insert(
-                            self.parse_clippy_lint_name(path.as_ref(), cursor.get_text(captures[1])),
-                            Lint::Deprecated(DeprecatedLint {
-                                reason: self.parse_str_single_line(path.as_ref(), cursor.get_text(captures[2])),
-                                version: self.parse_str_single_line(path.as_ref(), cursor.get_text(captures[0])),
-                            }),
+        if let Err(expected) = cursor
+            .find_ident("declare_with_version")
+            .ok_or("`declare_with_version`")
+            .and_then(|()| {
+                cursor
+                    .find_ident("declare_with_version")
+                    .ok_or("`declare_with_version`")
+            })
+            .and_then(|()| cursor.match_all(DEPRECATED_TOKENS, &mut []))
+            .and_then(|()| {
+                cursor.eat_list(|cursor| {
+                    let parsed = cursor.opt_match_all(DECL_TOKENS, &mut captures)?;
+                    let name_sp = captures[1].mk_sp(file);
+                    if parsed
+                        && let (Some(version), Some(name), Some(reason)) = (
+                            self.parse_version(cursor.get_text(captures[0]), captures[0].mk_sp(file)),
+                            self.parse_clippy_lint_name(cursor.get_text(captures[1]), name_sp),
+                            self.parse_str_lit(cursor.get_text(captures[2]), captures[0].mk_sp(file)),
                         )
-                        .is_none()
-                );
-            }
-        } else {
-            panic!("error reading deprecated lints");
-        }
-
-        if cursor.find_ident("declare_with_version").is_some() && cursor.match_all(RENAMED_TOKENS, &mut []) {
-            while cursor.match_all(DECL_TOKENS, &mut captures) {
-                assert!(
-                    data.lints
-                        .insert(
-                            self.parse_clippy_lint_name(path.as_ref(), cursor.get_text(captures[1])),
-                            Lint::Renamed(RenamedLint {
-                                new_name: self.parse_lint_name(path.as_ref(), cursor.get_text(captures[2])),
-                                version: self.parse_str_single_line(path.as_ref(), cursor.get_text(captures[0])),
-                            }),
+                        && let Some(e) = data.get_vacant_lint(&mut self.dcx, name, name_sp)
+                    {
+                        e.insert(Lint {
+                            name_sp,
+                            data: LintData::Deprecated(DeprecatedLint { reason, version }),
+                        });
+                    }
+                    Ok(parsed)
+                })
+            })
+            .and_then(|()| {
+                cursor
+                    .find_ident("declare_with_version")
+                    .ok_or("`declare_with_version`")
+            })
+            .and_then(|()| cursor.match_all(RENAMED_TOKENS, &mut []))
+            .and_then(|()| {
+                cursor.eat_list(|cursor| {
+                    let parsed = cursor.opt_match_all(DECL_TOKENS, &mut captures)?;
+                    let name_sp = captures[1].mk_sp(file);
+                    if parsed
+                        && let (Some(version), Some(name), Some(new_name)) = (
+                            self.parse_version(cursor.get_text(captures[0]), captures[0].mk_sp(file)),
+                            self.parse_clippy_lint_name(cursor.get_text(captures[1]), name_sp),
+                            self.parse_lint_name(cursor.get_text(captures[2]), captures[0].mk_sp(file)),
                         )
-                        .is_none()
-                );
-            }
-        } else {
-            panic!("error reading renamed lints");
+                        && let Some(e) = data.get_vacant_lint(&mut self.dcx, name, name_sp)
+                    {
+                        e.insert(Lint {
+                            name_sp,
+                            data: LintData::Renamed(RenamedLint { new_name, version }),
+                        });
+                    }
+                    Ok(parsed)
+                })
+            })
+        {
+            cursor.emit_unexpected(&mut self.dcx, file, expected);
         }
     }
 
-    /// Removes the line splices and surrounding quotes from a string literal
-    fn parse_str_lit(&mut self, s: &str) -> &'cx str {
-        let (s, is_raw) = if let Some(s) = s.strip_prefix("r") {
-            (s.trim_matches('#'), true)
+    /// Removes the line splices and surrounding quotes from a string literal.
+    fn parse_str_lit(&mut self, s: &'cx str, sp: Span<'cx>) -> Option<&'cx str> {
+        let (s, is_raw, sp_base) = if let Some(trimmed) = s.strip_prefix("r") {
+            let trimmed = trimmed.trim_start_matches('#');
+            #[expect(clippy::cast_possible_truncation)]
+            let sp_base = (s.len() - trimmed.len() + 1) as u32;
+            (trimmed.trim_end_matches('#'), true, sp_base)
         } else {
-            (s, false)
+            (s, false, 1)
         };
+        let sp_base = sp.range.start + sp_base;
         let s = s
             .strip_prefix('"')
             .and_then(|s| s.strip_suffix('"'))
             .unwrap_or_else(|| panic!("expected quoted string, found `{s}`"));
 
+        let mut is_ok = true;
         if is_raw {
-            if s.is_empty() { "" } else { self.arena.alloc_str(s) }
+            rustc_literal_escaper::check_raw_str(s, |range, c| {
+                if c.is_err_and(|e| e.is_fatal()) {
+                    #[expect(clippy::cast_possible_truncation)]
+                    let range = range.start as u32 + sp_base..range.end as u32 + sp_base;
+                    self.dcx
+                        .emit_spanned_err(Span::new(sp.file, range), "invalid string escape sequence");
+                    is_ok = false;
+                }
+            });
+            is_ok.then_some(s)
         } else {
             self.str_buf.with(|buf| {
-                rustc_literal_escaper::unescape_str(s, &mut |_, ch| {
-                    if let Ok(ch) = ch {
-                        buf.push(ch);
-                    }
+                rustc_literal_escaper::unescape_str(s, |range, c| match c {
+                    Ok(c) => buf.push(c),
+                    Err(e) if e.is_fatal() => {
+                        #[expect(clippy::cast_possible_truncation)]
+                        let range = range.start as u32 + sp_base..range.end as u32 + sp_base;
+                        self.dcx
+                            .emit_spanned_err(Span::new(sp.file, range), "invalid string escape sequence");
+                        is_ok = false;
+                    },
+                    Err(_) => {},
                 });
-                if buf.is_empty() { "" } else { self.arena.alloc_str(buf) }
+                is_ok.then(|| {
+                    if buf == s {
+                        s
+                    } else if buf.is_empty() {
+                        ""
+                    } else {
+                        self.arena.alloc_str(buf)
+                    }
+                })
             })
         }
     }
 
-    fn parse_str_single_line(&mut self, path: &Path, s: &str) -> &'cx str {
-        let value = self.parse_str_lit(s);
-        assert!(
-            !value.contains('\n'),
-            "error parsing `{}`: `{s}` should be a single line string",
-            path.display(),
-        );
-        value
+    #[track_caller]
+    fn parse_lint_name(&mut self, s: &'cx str, sp: Span<'cx>) -> Option<LintName<'cx>> {
+        let s = self.parse_str_lit(s, sp)?;
+        let (tool, name) = match s.split_once("::") {
+            Some((tool, name)) if let Some(tool) = LintTool::from_prefix(tool) => (tool, name),
+            Some(..) => {
+                self.dcx.emit_spanned_err(sp, "unknown lint tool");
+                return None;
+            },
+            None => (LintTool::Rustc, s),
+        };
+        if name
+            .bytes()
+            .all(|c| matches!(c, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_'))
+        {
+            Some(LintName { tool, name })
+        } else {
+            self.dcx.emit_spanned_err(sp, "unparsable lint name");
+            None
+        }
     }
 
-    fn parse_clippy_lint_name(&mut self, path: &Path, s: &str) -> &'cx str {
-        match self.parse_str_single_line(path, s).strip_prefix("clippy::") {
-            Some(x) => x,
-            None => panic!(
-                "error parsing `{}`: `{s}` should be a string starting with `clippy::`",
-                path.display()
-            ),
+    #[track_caller]
+    fn parse_clippy_lint_name(&mut self, s: &'cx str, sp: Span<'cx>) -> Option<&'cx str> {
+        let name = self.parse_lint_name(s, sp)?;
+        if name.tool == LintTool::Clippy {
+            Some(name.name)
+        } else {
+            self.dcx.emit_not_clippy_lint_name(sp);
+            None
         }
     }
 
-    fn parse_lint_name(&mut self, path: &Path, s: &str) -> LintName<'cx> {
-        let s = self.parse_str_single_line(path, s);
-        let (name, tool) = match s.strip_prefix("clippy::") {
-            Some(s) => (s, LintTool::Clippy),
-            None => (s, LintTool::Rustc),
-        };
-        LintName { name, tool }
+    #[track_caller]
+    fn parse_version(&mut self, s: &'cx str, sp: Span<'cx>) -> Option<&'cx str> {
+        let s = self.parse_str_lit(s, sp)?;
+        if s.bytes().all(|c| matches!(c, b'0'..=b'9' | b'.')) || matches!(s, "pre 1.29.0" | "CURRENT_RUSTC_VERSION") {
+            Some(s)
+        } else {
+            self.dcx.emit_spanned_err(sp, "unparsable version number");
+            None
+        }
     }
 }
diff --git a/clippy_dev/src/parse/cursor.rs b/clippy_dev/src/parse/cursor.rs
index 2c142af4883a..5b27ef97da02 100644
--- a/clippy_dev/src/parse/cursor.rs
+++ b/clippy_dev/src/parse/cursor.rs
@@ -1,5 +1,8 @@
-use core::slice;
-use rustc_lexer::{self as lex, LiteralKind, Token, TokenKind};
+use crate::utils::{StrBuf, VecBuf};
+use crate::{DiagCx, SourceFile, Span};
+use core::{ptr, slice};
+use rustc_arena::DroplessArena;
+use rustc_lexer::{self as lex, DocStyle, LiteralKind, Token, TokenKind};
 
 /// A token pattern used for searching and matching by the [`Cursor`].
 ///
@@ -8,29 +11,98 @@ use rustc_lexer::{self as lex, LiteralKind, Token, TokenKind};
 /// `DoubleColon` will consume the first `:` and then fail to match, leaving the cursor at
 /// the `*`.
 #[derive(Clone, Copy)]
-pub enum Pat<'a> {
+pub enum Pat {
     /// Matches any number of comments and doc comments.
-    AnyComment,
-    Ident(&'a str),
+    AnyComments,
+    CaptureDocLines,
     CaptureIdent,
-    LitStr,
+    CaptureLifetime,
     CaptureLitStr,
+    AnyIdent,
+    At,
     Bang,
-    CloseBrace,
     CloseBracket,
     CloseParen,
+    Colon,
     Comma,
     DoubleColon,
     Eq,
+    FatArrow,
+    Gt,
+    Ident(IdentPat),
     Lifetime,
+    Lit,
+    LitStr,
     Lt,
-    Gt,
     OpenBrace,
     OpenBracket,
     OpenParen,
     Pound,
     Semi,
 }
+impl Pat {
+    pub fn desc(self) -> &'static str {
+        match self {
+            Self::AnyComments => "comments",
+            Self::CaptureDocLines => "doc line comments",
+            Self::AnyIdent | Self::CaptureIdent => "an identifier",
+            Self::At => "`@`",
+            Self::Bang => "`!`",
+            Self::CloseBracket => "`]`",
+            Self::CloseParen => "`)`",
+            Self::Colon => "`:`",
+            Self::Comma => "`,`",
+            Self::DoubleColon => "`::`",
+            Self::Eq => "`=`",
+            Self::FatArrow => "`=>`",
+            Self::Gt => "`>`",
+            Self::Ident(x) => x.desc(),
+            Self::Lifetime | Self::CaptureLifetime => "a lifetime",
+            Self::Lit => "a literal",
+            Self::LitStr | Self::CaptureLitStr => "a string literal",
+            Self::Lt => "`<`",
+            Self::OpenBrace => "`{`",
+            Self::OpenBracket => "`[`",
+            Self::OpenParen => "`(`",
+            Self::Pound => "`#`",
+            Self::Semi => "`;`",
+        }
+    }
+}
+
+macro_rules! ident_or_lit {
+    ($ident:ident) => {
+        stringify!($ident)
+    };
+    ($_ident:ident $lit:literal) => {
+        $lit
+    };
+}
+macro_rules! decl_ident_pats {
+    ($($ident:ident $(= $s:literal)?,)*) => {
+        #[allow(non_camel_case_types, clippy::upper_case_acronyms)]
+        #[derive(Clone, Copy)]
+        pub enum IdentPat { $($ident),* }
+        impl IdentPat {
+            pub fn as_str(self) -> &'static str {
+                match self { $(Self::$ident => ident_or_lit!($ident $($s)?)),* }
+            }
+
+            pub fn desc(self) -> &'static str {
+                match self { $(Self::$ident => concat!("`", ident_or_lit!($ident $($s)?), "`")),* }
+            }
+        }
+    }
+}
+decl_ident_pats! {
+    DEPRECATED,
+    DEPRECATED_VERSION,
+    RENAMED,
+    RENAMED_VERSION,
+    clippy,
+    r#pub = "pub",
+    version,
+}
 
 #[derive(Clone, Copy)]
 pub struct Capture {
@@ -39,6 +111,13 @@ pub struct Capture {
 }
 impl Capture {
     pub const EMPTY: Self = Self { pos: 0, len: 0 };
+
+    pub fn mk_sp<'cx>(self, file: &'cx SourceFile<'cx>) -> Span<'cx> {
+        Span {
+            file,
+            range: self.pos..self.pos + self.len,
+        }
+    }
 }
 
 /// A unidirectional cursor over a token stream that is lexed on demand.
@@ -93,12 +172,6 @@ impl<'txt> Cursor<'txt> {
         self.pos
     }
 
-    /// Gets whether the cursor has exhausted its input.
-    #[must_use]
-    pub fn at_end(&self) -> bool {
-        self.next_token.kind == TokenKind::Eof
-    }
-
     /// Advances the cursor to the next token. If the stream is exhausted this will set
     /// the next token to [`TokenKind::Eof`].
     pub fn step(&mut self) {
@@ -107,28 +180,45 @@ impl<'txt> Cursor<'txt> {
         self.next_token = self.inner.advance_token();
     }
 
+    #[track_caller]
+    pub fn emit_unexpected<'cx>(&self, dcx: &mut DiagCx, file: &'cx SourceFile<'cx>, expected: &'static str) {
+        let sp = Span::new(file, self.pos..self.pos + self.next_token.len);
+        let msg = if matches!(self.next_token.kind, TokenKind::Eof) {
+            "end of file"
+        } else {
+            "token"
+        };
+        dcx.emit_spanned_err(sp, format!("unexpected {msg}, expected {expected}"));
+    }
+
     /// Consumes tokens until the given pattern is either fully matched of fails to match.
     /// Returns whether the pattern was fully matched.
     ///
     /// For each capture made by the pattern one item will be taken from the capture
     /// sequence with the result placed inside.
-    fn match_impl(&mut self, pat: Pat<'_>, captures: &mut slice::IterMut<'_, Capture>) -> bool {
+    fn match_impl(&mut self, pat: Pat, captures: &mut slice::IterMut<'_, Capture>) -> bool {
         loop {
             match (pat, self.next_token.kind) {
                 #[rustfmt::skip] // rustfmt bug: https://github.com/rust-lang/rustfmt/issues/6697
                 (_, TokenKind::Whitespace)
                 | (
-                    Pat::AnyComment,
+                    Pat::AnyComments,
                     TokenKind::BlockComment { terminated: true, .. } | TokenKind::LineComment { .. },
                 ) => self.step(),
-                (Pat::AnyComment, _) => return true,
-                (Pat::Bang, TokenKind::Bang)
-                | (Pat::CloseBrace, TokenKind::CloseBrace)
+                (Pat::AnyComments, _) => return true,
+
+                (Pat::Ident(x), TokenKind::Ident) if x.as_str() == self.peek_text() => break,
+                (Pat::Lit, TokenKind::Ident) if matches!(self.peek_text(), "true" | "false") => break,
+                (Pat::At, TokenKind::At)
+                | (Pat::AnyIdent, TokenKind::Ident | TokenKind::RawIdent)
+                | (Pat::Bang, TokenKind::Bang)
                 | (Pat::CloseBracket, TokenKind::CloseBracket)
                 | (Pat::CloseParen, TokenKind::CloseParen)
+                | (Pat::Colon, TokenKind::Colon)
                 | (Pat::Comma, TokenKind::Comma)
                 | (Pat::Eq, TokenKind::Eq)
                 | (Pat::Lifetime, TokenKind::Lifetime { .. })
+                | (Pat::Lit, TokenKind::Literal { .. })
                 | (Pat::Lt, TokenKind::Lt)
                 | (Pat::Gt, TokenKind::Gt)
                 | (Pat::OpenBrace, TokenKind::OpenBrace)
@@ -142,22 +232,17 @@ impl<'txt> Cursor<'txt> {
                         kind: LiteralKind::Str { terminated: true } | LiteralKind::RawStr { .. },
                         ..
                     },
-                ) => {
-                    self.step();
-                    return true;
-                },
-                (Pat::Ident(x), TokenKind::Ident) if x == self.peek_text() => {
+                ) => break,
+
+                (Pat::DoubleColon, TokenKind::Colon) if self.inner.as_str().starts_with(':') => {
                     self.step();
-                    return true;
+                    break;
                 },
-                (Pat::DoubleColon, TokenKind::Colon) => {
+                (Pat::FatArrow, TokenKind::Eq) if self.inner.as_str().starts_with('>') => {
                     self.step();
-                    if !self.at_end() && matches!(self.next_token.kind, TokenKind::Colon) {
-                        self.step();
-                        return true;
-                    }
-                    return false;
+                    break;
                 },
+
                 #[rustfmt::skip]
                 (
                     Pat::CaptureLitStr,
@@ -168,43 +253,67 @@ impl<'txt> Cursor<'txt> {
                         ..
                     },
                 )
-                | (Pat::CaptureIdent, TokenKind::Ident) => {
+                | (Pat::CaptureIdent, TokenKind::Ident)
+                | (Pat::CaptureLifetime, TokenKind::Lifetime { .. }) => {
                     *captures.next().unwrap() = Capture { pos: self.pos, len: self.next_token.len };
                     self.step();
                     return true;
                 },
+
+                (
+                    Pat::CaptureDocLines,
+                    TokenKind::LineComment {
+                        doc_style: Some(DocStyle::Outer),
+                    },
+                ) => {
+                    let pos = self.pos;
+                    self.eat_doc_lines();
+                    *captures.next().unwrap() = Capture {
+                        pos,
+                        len: self.pos - pos,
+                    };
+                    return true;
+                },
+                (Pat::CaptureDocLines, _) => {
+                    *captures.next().unwrap() = Capture::EMPTY;
+                    return true;
+                },
+
                 _ => return false,
             }
         }
+
+        self.step();
+        true
     }
 
-    /// Consumes all tokens until the specified identifier is found and returns its
-    /// position. Returns `None` if the identifier could not be found.
-    ///
-    /// The cursor will be positioned immediately after the identifier, or at the end if
-    /// it is not.
-    pub fn find_ident(&mut self, ident: &str) -> Option<u32> {
+    /// Consumes and captures the next non-whitespace token if it's an identifier. Returns
+    /// `None` otherwise.
+    #[must_use]
+    pub fn capture_ident(&mut self) -> Option<Capture> {
         loop {
             match self.next_token.kind {
-                TokenKind::Ident if self.peek_text() == ident => {
-                    let pos = self.pos;
+                TokenKind::Whitespace => self.step(),
+                TokenKind::Ident => {
+                    let res = Capture {
+                        pos: self.pos,
+                        len: self.next_token.len,
+                    };
                     self.step();
-                    return Some(pos);
+                    return Some(res);
                 },
-                TokenKind::Eof => return None,
-                _ => self.step(),
+                _ => return None,
             }
         }
     }
 
-    /// Consumes all tokens until the next identifier is found and captures it. Returns
-    /// `None` if no identifier could be found.
-    ///
-    /// The cursor will be positioned immediately after the identifier, or at the end if
-    /// it is not.
-    pub fn find_any_ident(&mut self) -> Option<Capture> {
+    /// Consumes all tokens up to and including the next identifier. Returns either the
+    /// captured identifier or `None` if one was not found.
+    #[must_use]
+    pub fn find_capture_ident(&mut self) -> Option<Capture> {
         loop {
             match self.next_token.kind {
+                TokenKind::Eof => return None,
                 TokenKind::Ident => {
                     let res = Capture {
                         pos: self.pos,
@@ -213,43 +322,168 @@ impl<'txt> Cursor<'txt> {
                     self.step();
                     return Some(res);
                 },
-                TokenKind::Eof => return None,
                 _ => self.step(),
             }
         }
     }
 
-    /// Consume the returns the position of the next non-whitespace token if it's an
-    /// identifier. Returns `None` otherwise.
-    pub fn match_ident(&mut self, s: &str) -> Option<u32> {
+    /// Finds the next call to a macro with the specified name and returns it's captured
+    /// name.
+    #[must_use]
+    pub fn find_mac_call(&mut self, name: &str) -> Option<Capture> {
+        while let Some(mac) = self.find_capture_ident() {
+            if self.eat_bang() && self.get_text(mac) == name {
+                return Some(mac);
+            }
+        }
+        None
+    }
+
+    /// Consumes and captures the text of a path without any internal whitespace. Returns
+    /// `Err` if the path ends with `::`, and `None` if no path component exists at the
+    /// current position.
+    ///
+    /// Only paths containing identifiers separated by `::` with a possible leading `::`.
+    /// Generic arguments and qualified paths are not considered.
+    pub fn capture_opt_path(
+        &mut self,
+        buf: &mut StrBuf,
+        arena: &'txt DroplessArena,
+    ) -> Result<Option<&'txt str>, &'static str> {
+        #[derive(Clone, Copy)]
+        enum State {
+            Start,
+            Sep,
+            Ident,
+        }
+
+        buf.with(|buf| {
+            let start = self.pos;
+            let mut state = State::Start;
+            loop {
+                match (state, self.next_token.kind) {
+                    (_, TokenKind::Whitespace) => self.step(),
+                    (State::Start | State::Ident, TokenKind::Colon) if self.inner.first() == ':' => {
+                        state = State::Sep;
+                        buf.push_str("::");
+                        self.step();
+                        self.step();
+                    },
+                    (State::Start | State::Sep, TokenKind::Ident) => {
+                        state = State::Ident;
+                        buf.push_str(self.peek_text());
+                        self.step();
+                    },
+                    (State::Ident, _) => break,
+                    (State::Start, _) => return Ok(None),
+                    (State::Sep, _) => return Err(Pat::AnyIdent.desc()),
+                }
+            }
+            let text = self.text[start as usize..self.pos as usize].trim();
+            Ok(Some(if text.len() == buf.len() {
+                text
+            } else {
+                arena.alloc_str(buf)
+            }))
+        })
+    }
+
+    pub fn eat_list(&mut self, mut f: impl FnMut(&mut Self) -> Result<bool, &'static str>) -> Result<(), &'static str> {
+        while f(self)? {
+            if !self.eat_comma() {
+                break;
+            }
+        }
+        Ok(())
+    }
+
+    pub fn capture_list<'cx, T: Copy>(
+        &mut self,
+        buf: &mut VecBuf<T>,
+        arena: &'cx DroplessArena,
+        mut f: impl FnMut(&mut Self) -> Result<Option<T>, &'static str>,
+    ) -> Result<&'cx mut [T], &'static str> {
+        buf.with(|buf| {
+            while let Some(x) = f(self)? {
+                buf.push(x);
+                if !self.eat_comma() {
+                    break;
+                }
+            }
+            Ok(if buf.is_empty() {
+                &mut []
+            } else {
+                arena.alloc_slice(buf)
+            })
+        })
+    }
+
+    /// Consumes all doc line comments until another non-whitespace token is found.
+    pub fn eat_doc_lines(&mut self) {
+        while matches!(
+            self.next_token.kind,
+            TokenKind::Whitespace
+                | TokenKind::LineComment {
+                    doc_style: Some(DocStyle::Outer)
+                }
+        ) {
+            self.step();
+        }
+    }
+
+    /// Consumes and captures all doc line comments until another non-whitespace token is
+    /// found.
+    pub fn capture_doc_lines(&mut self) -> Capture {
         loop {
             match self.next_token.kind {
-                TokenKind::Ident if s == self.peek_text() => {
+                TokenKind::Whitespace => self.step(),
+                TokenKind::LineComment {
+                    doc_style: Some(DocStyle::Outer),
+                } => {
                     let pos = self.pos;
                     self.step();
-                    return Some(pos);
+                    self.eat_doc_lines();
+                    return Capture {
+                        pos,
+                        len: self.pos - pos,
+                    };
                 },
-                TokenKind::Whitespace => self.step(),
-                _ => return None,
+                _ => return Capture { pos: self.pos, len: 0 },
             }
         }
     }
 
-    /// Continually attempt to match the pattern on subsequent tokens until a match is
-    /// found. Returns whether the pattern was successfully matched.
-    ///
-    /// Not generally suitable for multi-token patterns or patterns that can match
-    /// nothing.
-    #[must_use]
-    pub fn find_pat(&mut self, pat: Pat<'_>) -> bool {
-        let mut capture = [].iter_mut();
-        while !self.match_impl(pat, &mut capture) {
-            self.step();
-            if self.at_end() {
-                return false;
+    /// Consumes and captures the next outer attribute. Returns `Err` is the attribute
+    /// could not be parsed and `None` if the next token does not start an attribute.
+    pub fn capture_opt_attr_start(&mut self) -> Result<Option<(u32, Capture)>, &'static str> {
+        if !self.eat_pound() {
+            return Ok(None);
+        }
+        let start = self.pos - 1;
+        self.eat_open_bracket()
+            .ok_or("`[`")
+            .and_then(|()| self.capture_ident().ok_or("an identifier"))
+            .map(|name| Some((start, name)))
+    }
+
+    /// Consumes everything until the end of a list item indicated by either an unwrapped
+    /// comma or an unmatched closing delimiter.
+    pub fn eat_list_item(&mut self) {
+        let mut depth: u32 = 0;
+        loop {
+            match self.next_token.kind {
+                TokenKind::OpenBrace | TokenKind::OpenBracket | TokenKind::OpenParen => depth += 1,
+                TokenKind::CloseBrace | TokenKind::CloseBracket | TokenKind::CloseParen if depth > 0 => depth -= 1,
+                TokenKind::Comma if depth > 0 => {},
+                TokenKind::Eof
+                | TokenKind::Comma
+                | TokenKind::CloseBrace
+                | TokenKind::CloseBracket
+                | TokenKind::CloseParen => break,
+                _ => {},
             }
+            self.step();
         }
-        true
     }
 
     /// Attempts to match a sequence of patterns at the current position. Returns whether
@@ -261,19 +495,103 @@ impl<'txt> Cursor<'txt> {
     /// unmodified.
     ///
     /// If the match fails the cursor will be positioned at the first failing token.
-    #[must_use]
-    pub fn match_all(&mut self, pats: &[Pat<'_>], captures: &mut [Capture]) -> bool {
+    pub fn match_all(&mut self, pats: &[Pat], captures: &mut [Capture]) -> Result<(), &'static str> {
         let mut captures = captures.iter_mut();
-        pats.iter().all(|&p| self.match_impl(p, &mut captures))
+        pats.iter()
+            .try_for_each(|&pat| self.match_impl(pat, &mut captures).ok_or(pat.desc()))
     }
 
-    /// Attempts to match a single pattern at the current position. Returns whether the
-    /// pattern was successfully matched.
+    /// Attempts to match a sequence of patterns at the current position. Returns whether
+    /// all patterns were successfully matched.
     ///
-    /// If the pattern attempts to capture anything this will panic. If the match fails
-    /// the cursor will be positioned at the first failing token.
-    #[must_use]
-    pub fn match_pat(&mut self, pat: Pat<'_>) -> bool {
-        self.match_impl(pat, &mut [].iter_mut())
+    /// Captures will be written to the given slice in the order they're matched. If a
+    /// capture is matched, but there are no more capture slots this will panic. If the
+    /// match is completed without filling all the capture slots they will be left
+    /// unmodified.
+    ///
+    /// If the match fails the cursor will be positioned at the first failing token.
+    pub fn opt_match_all(&mut self, pats: &[Pat], captures: &mut [Capture]) -> Result<bool, &'static str> {
+        let mut captures = captures.iter_mut();
+        match pats
+            .iter()
+            .try_for_each(|p| self.match_impl(*p, &mut captures).ok_or(p))
+        {
+            Ok(()) => Ok(true),
+            Err(p) if ptr::addr_eq(pats.as_ptr(), p) => Ok(false),
+            Err(p) => Err(p.desc()),
+        }
+    }
+}
+
+macro_rules! mk_tk_methods {
+    ($(
+        [$desc:literal]
+        $name:ident(&mut $self:tt $($params:tt)*)
+            { $pat:pat $(if $guard:expr)? $(=> $extra:block)? }
+    )*) => {
+        #[allow(dead_code)]
+        impl Cursor<'_> {$(
+            #[doc = "Consumes the next non-whitespace token if it's "]
+            #[doc = $desc]
+            #[doc = " and returns whether the token was found."]
+            #[must_use]
+            pub fn ${concat(eat_, $name)}(&mut $self $($params)*) -> bool {
+                loop {
+                    match $self.next_token.kind {
+                        TokenKind::Whitespace => $self.step(),
+                        $pat $(if $guard)? => {
+                            $self.step();
+                            return true;
+                        },
+                        _ => return false,
+                    }
+                }
+            }
+
+            #[doc = "Consumes all tokens up to and including "]
+            #[doc = $desc]
+            #[doc = " and returns whether the token was found."]
+            #[must_use]
+            pub fn ${concat(find_, $name)}(&mut $self $($params)*) -> bool {
+                loop {
+                    match $self.next_token.kind {
+                        TokenKind::Eof => return false,
+                        $pat $(if $guard)? => {
+                            $self.step();
+                            return true;
+                        },
+                        _ => $self.step(),
+                    }
+                }
+            }
+        )*}
+    }
+}
+mk_tk_methods! {
+    ["`!`"]
+    bang(&mut self) { TokenKind::Bang }
+    ["`}`"]
+    close_brace(&mut self) { TokenKind::CloseBrace }
+    ["`]`"]
+    close_bracket(&mut self) { TokenKind::CloseBracket }
+    ["`,`"]
+    comma(&mut self) { TokenKind::Comma }
+    ["`::`"]
+    double_colon(&mut self) {
+        TokenKind::Colon if self.inner.as_str().starts_with(':') => { self.step(); }
     }
+    ["`=`"]
+    eq(&mut self) { TokenKind::Eq }
+    ["the specified identifier"]
+    ident(&mut self, s: &str) { TokenKind::Ident if self.peek_text() == s }
+    ["`{`"]
+    open_brace(&mut self) { TokenKind::OpenBrace }
+    ["`[`"]
+    open_bracket(&mut self) { TokenKind::OpenBracket }
+    ["`(`"]
+    open_paren(&mut self) { TokenKind::OpenParen }
+    ["`#`"]
+    pound(&mut self) { TokenKind::Pound }
+    ["`;`"]
+    semi(&mut self) { TokenKind::Semi }
 }
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
deleted file mode 100644
index a4cf15058986..000000000000
--- a/clippy_dev/src/update_lints.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-use crate::parse::cursor::Cursor;
-use crate::parse::{Lint, LintData, ParseCx};
-use crate::utils::{FileUpdater, UpdateMode, UpdateStatus, update_text_region_fn};
-use itertools::Itertools;
-use std::collections::HashSet;
-use std::fmt::Write;
-use std::path::{self, Path};
-
-const GENERATED_FILE_COMMENT: &str = "// This file was generated by `cargo dev update_lints`.\n\
-     // Use that command to update this file and do not edit by hand.\n\
-     // Manual edits will be overwritten.\n\n";
-
-const DOCS_LINK: &str = "https://rust-lang.github.io/rust-clippy/master/index.html";
-
-/// Runs the `update_lints` command.
-///
-/// This updates various generated values from the lint source code.
-///
-/// `update_mode` indicates if the files should be updated or if updates should be checked for.
-///
-/// # Panics
-///
-/// Panics if a file path could not read from or then written to
-pub fn update(cx: ParseCx<'_>, update_mode: UpdateMode) {
-    let data = cx.parse_lint_decls();
-    generate_lint_files(update_mode, &data);
-}
-
-#[expect(clippy::too_many_lines)]
-pub fn generate_lint_files(update_mode: UpdateMode, data: &LintData<'_>) {
-    let mut updater = FileUpdater::default();
-
-    let mut lints: Vec<_> = data.lints.iter().map(|(&x, y)| (x, y)).collect();
-    lints.sort_by_key(|&(x, _)| x);
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "CHANGELOG.md",
-        &mut update_text_region_fn(
-            "<!-- begin autogenerated links to lint list -->\n",
-            "<!-- end autogenerated links to lint list -->",
-            |dst| {
-                for &(lint, _) in &lints {
-                    writeln!(dst, "[`{lint}`]: {DOCS_LINK}#{lint}").unwrap();
-                }
-            },
-        ),
-    );
-
-    let mut active = Vec::with_capacity(lints.len());
-    let mut deprecated = Vec::with_capacity(lints.len() / 8);
-    let mut renamed = Vec::with_capacity(lints.len() / 8);
-    for &(name, lint) in &lints {
-        match lint {
-            Lint::Active(lint) => active.push((name, lint)),
-            Lint::Deprecated(lint) => deprecated.push((name, lint)),
-            Lint::Renamed(lint) => renamed.push((name, lint)),
-        }
-    }
-    active.sort_by_key(|&(_, lint)| lint.module);
-
-    // Round to avoid updating the readme every time a lint is added/deprecated.
-    let lint_count = active.len() / 50 * 50;
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "README.md",
-        &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
-            write!(dst, "{lint_count}").unwrap();
-        }),
-    );
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "book/src/README.md",
-        &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
-            write!(dst, "{lint_count}").unwrap();
-        }),
-    );
-
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "clippy_lints/src/deprecated_lints.rs",
-        &mut |_, src, dst| {
-            let mut cursor = Cursor::new(src);
-            assert!(
-                cursor.find_ident("declare_with_version").is_some()
-                    && cursor.find_ident("declare_with_version").is_some(),
-                "error reading deprecated lints"
-            );
-            dst.push_str(&src[..cursor.pos() as usize]);
-            dst.push_str("! { DEPRECATED(DEPRECATED_VERSION) = [\n");
-            for &(name, data) in &deprecated {
-                write!(
-                    dst,
-                    "    #[clippy::version = \"{}\"]\n    (\"clippy::{name}\", \"{}\"),\n",
-                    data.version, data.reason,
-                )
-                .unwrap();
-            }
-            dst.push_str(
-                "]}\n\n\
-                    #[rustfmt::skip]\n\
-                    declare_with_version! { RENAMED(RENAMED_VERSION) = [\n\
-                ",
-            );
-            for &(name, data) in &renamed {
-                write!(
-                    dst,
-                    "    #[clippy::version = \"{}\"]\n    (\"clippy::{name}\", \"{}\"),\n",
-                    data.version, data.new_name,
-                )
-                .unwrap();
-            }
-            dst.push_str("]}\n");
-            UpdateStatus::from_changed(src != dst)
-        },
-    );
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "tests/ui/deprecated.rs",
-        &mut |_, src, dst| {
-            dst.push_str(GENERATED_FILE_COMMENT);
-            for &(lint, _) in &deprecated {
-                writeln!(dst, "#![warn(clippy::{lint})] //~ ERROR: lint `clippy::{lint}`").unwrap();
-            }
-            dst.push_str("\nfn main() {}\n");
-            UpdateStatus::from_changed(src != dst)
-        },
-    );
-    updater.update_file_checked(
-        "cargo dev update_lints",
-        update_mode,
-        "tests/ui/rename.rs",
-        &mut move |_, src, dst| {
-            let mut seen_lints = HashSet::new();
-            dst.push_str(GENERATED_FILE_COMMENT);
-            dst.push_str("#![allow(clippy::duplicated_attributes)]\n");
-            for &(_, lint) in &renamed {
-                if seen_lints.insert(lint.new_name) {
-                    writeln!(dst, "#![allow({})]", lint.new_name).unwrap();
-                }
-            }
-            for &(lint, _) in &renamed {
-                writeln!(dst, "#![warn(clippy::{lint})] //~ ERROR: lint `clippy::{lint}`").unwrap();
-            }
-            dst.push_str("\nfn main() {}\n");
-            UpdateStatus::from_changed(src != dst)
-        },
-    );
-    for (crate_name, lints) in active.iter().copied().into_group_map_by(|&(_, lint)| {
-        let Some(path::Component::Normal(name)) = lint.path.components().next() else {
-            // All paths should start with `{crate_name}/src` when parsed from `find_lint_decls`
-            panic!(
-                "internal error: can't read crate name from path `{}`",
-                lint.path.display()
-            );
-        };
-        name
-    }) {
-        updater.update_file_checked(
-            "cargo dev update_lints",
-            update_mode,
-            Path::new(crate_name).join("src/lib.rs"),
-            &mut update_text_region_fn(
-                "// begin lints modules, do not remove this comment, it's used in `update_lints`\n",
-                "// end lints modules, do not remove this comment, it's used in `update_lints`",
-                |dst| {
-                    let mut prev = "";
-                    for &(_, lint) in &lints {
-                        if lint.module != prev {
-                            writeln!(dst, "mod {};", lint.module).unwrap();
-                            prev = lint.module;
-                        }
-                    }
-                },
-            ),
-        );
-        updater.update_file_checked(
-            "cargo dev update_lints",
-            update_mode,
-            Path::new(crate_name).join("src/declared_lints.rs"),
-            &mut |_, src, dst| {
-                dst.push_str(GENERATED_FILE_COMMENT);
-                dst.push_str("pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[\n");
-                let mut buf = String::new();
-                for &(name, lint) in &lints {
-                    buf.clear();
-                    buf.push_str(name);
-                    buf.make_ascii_uppercase();
-                    if lint.module.is_empty() {
-                        writeln!(dst, "    crate::{buf}_INFO,").unwrap();
-                    } else {
-                        writeln!(dst, "    crate::{}::{buf}_INFO,", lint.module).unwrap();
-                    }
-                }
-                dst.push_str("];\n");
-                UpdateStatus::from_changed(src != dst)
-            },
-        );
-    }
-}
diff --git a/clippy_dev/src/utils.rs b/clippy_dev/src/utils.rs
index 52452dd86b49..58833be15f59 100644
--- a/clippy_dev/src/utils.rs
+++ b/clippy_dev/src/utils.rs
@@ -1,13 +1,19 @@
-use core::fmt::{self, Display};
+use core::cell::{Cell, OnceCell};
+use core::fmt::{self, Display, Write as _};
+use core::hash::{Hash, Hasher};
 use core::marker::PhantomData;
 use core::num::NonZero;
 use core::ops::{Deref, DerefMut};
 use core::range::Range;
 use core::str::FromStr;
+use core::str::pattern::Pattern;
+use core::{mem, ptr};
+use memchr::memchr_iter;
+use rustc_arena::DroplessArena;
 use std::ffi::OsStr;
 use std::fs::{self, OpenOptions};
 use std::io::{self, Read as _, Seek as _, SeekFrom, Write};
-use std::path::{Path, PathBuf};
+use std::path::{self, Path, PathBuf};
 use std::process::{self, Command, Stdio};
 use std::{env, thread};
 use walkdir::WalkDir;
@@ -95,13 +101,10 @@ impl<'a> File<'a> {
         }
     }
 
-    /// Opens and reads a file into a string, panicking of failure.
+    /// Opens a file for reading, panicking of failure.
     #[track_caller]
-    pub fn open_read_to_cleared_string<'dst>(
-        path: &'a (impl AsRef<Path> + ?Sized),
-        dst: &'dst mut String,
-    ) -> &'dst mut String {
-        Self::open(path, OpenOptions::new().read(true)).read_to_cleared_string(dst)
+    pub fn open_read(path: &'a (impl AsRef<Path> + ?Sized)) -> Self {
+        Self::open(path, OpenOptions::new().read(true))
     }
 
     /// Read the entire contents of a file to the given buffer.
@@ -117,13 +120,19 @@ impl<'a> File<'a> {
         self.read_append_to_string(dst)
     }
 
+    /// Writes the entire contents of the specified buffer to the file, panicking on failure.
+    #[track_caller]
+    pub fn write(&mut self, data: &[u8]) {
+        expect_action(self.inner.write_all(data), ErrAction::Write, self.path);
+    }
+
     /// Replaces the entire contents of a file.
     #[track_caller]
     pub fn replace_contents(&mut self, data: &[u8]) {
         let res = match self.inner.seek(SeekFrom::Start(0)) {
-            Ok(_) => match self.inner.write_all(data) {
-                Ok(()) => self.inner.set_len(data.len() as u64),
-                Err(e) => Err(e),
+            Ok(_) => {
+                self.write(data);
+                self.inner.set_len(data.len() as u64)
             },
             Err(e) => Err(e),
         };
@@ -363,6 +372,34 @@ impl FileUpdater {
         }
     }
 
+    #[track_caller]
+    pub fn update_loaded_file_checked(
+        &mut self,
+        tool: &str,
+        mode: UpdateMode,
+        file: &SourceFile<'_>,
+        update: &mut dyn FnMut(&Path, &str, &mut String) -> UpdateStatus,
+    ) {
+        self.dst_buf.clear();
+        match (
+            mode,
+            update(file.path.get().as_ref(), &file.contents, &mut self.dst_buf),
+        ) {
+            (UpdateMode::Check, UpdateStatus::Changed) => {
+                eprintln!(
+                    "the contents of `{}` are out of date\nplease run `{tool}` to update",
+                    file.path.get(),
+                );
+                process::exit(1);
+            },
+            (UpdateMode::Change, UpdateStatus::Changed) => {
+                File::open(file.path.get(), OpenOptions::new().truncate(true).write(true))
+                    .write(self.dst_buf.as_bytes());
+            },
+            (UpdateMode::Check | UpdateMode::Change, UpdateStatus::Unchanged) => {},
+        }
+    }
+
     #[track_caller]
     fn update_file_inner(&mut self, path: &Path, update: &mut dyn FnMut(&Path, &str, &mut String) -> UpdateStatus) {
         let mut file = File::open(path, OpenOptions::new().read(true).write(true));
@@ -429,51 +466,59 @@ pub fn update_text_region_fn(
 }
 
 #[track_caller]
-pub fn try_rename_file(old_name: &Path, new_name: &Path) -> bool {
-    match OpenOptions::new().create_new(true).write(true).open(new_name) {
-        Ok(file) => drop(file),
-        Err(e) if matches!(e.kind(), io::ErrorKind::AlreadyExists | io::ErrorKind::NotFound) => return false,
-        Err(ref e) => panic_action(e, ErrAction::Create, new_name),
-    }
-    match fs::rename(old_name, new_name) {
-        Ok(()) => true,
-        Err(ref e) => {
-            drop(fs::remove_file(new_name));
-            // `NotADirectory` happens on posix when renaming a directory to an existing file.
-            // Windows will ignore this and rename anyways.
-            if matches!(e.kind(), io::ErrorKind::NotFound | io::ErrorKind::NotADirectory) {
-                false
-            } else {
-                panic_action(e, ErrAction::Rename, old_name);
-            }
-        },
+pub fn try_rename_file(old_name: impl AsRef<Path>, new_name: impl AsRef<Path>) -> bool {
+    #[track_caller]
+    fn f(old_name: &Path, new_name: &Path) -> bool {
+        match OpenOptions::new().create_new(true).write(true).open(new_name) {
+            Ok(file) => drop(file),
+            Err(e) if matches!(e.kind(), io::ErrorKind::AlreadyExists | io::ErrorKind::NotFound) => return false,
+            Err(ref e) => panic_action(e, ErrAction::Create, new_name),
+        }
+        match fs::rename(old_name, new_name) {
+            Ok(()) => true,
+            Err(ref e) => {
+                drop(fs::remove_file(new_name));
+                // `NotADirectory` happens on posix when renaming a directory to an existing file.
+                // Windows will ignore this and rename anyways.
+                if matches!(e.kind(), io::ErrorKind::NotFound | io::ErrorKind::NotADirectory) {
+                    false
+                } else {
+                    panic_action(e, ErrAction::Rename, old_name);
+                }
+            },
+        }
     }
+    f(old_name.as_ref(), new_name.as_ref())
 }
 
 #[track_caller]
-pub fn try_rename_dir(old_name: &Path, new_name: &Path) -> bool {
-    match fs::create_dir(new_name) {
-        Ok(()) => {},
-        Err(e) if matches!(e.kind(), io::ErrorKind::AlreadyExists | io::ErrorKind::NotFound) => return false,
-        Err(ref e) => panic_action(e, ErrAction::Create, new_name),
-    }
-    // Windows can't reliably rename to an empty directory.
-    #[cfg(windows)]
-    drop(fs::remove_dir(new_name));
-    match fs::rename(old_name, new_name) {
-        Ok(()) => true,
-        Err(ref e) => {
-            // Already dropped earlier on windows.
-            #[cfg(not(windows))]
-            drop(fs::remove_dir(new_name));
-            // `NotADirectory` happens on posix when renaming a file to an existing directory.
-            if matches!(e.kind(), io::ErrorKind::NotFound | io::ErrorKind::NotADirectory) {
-                false
-            } else {
-                panic_action(e, ErrAction::Rename, old_name);
-            }
-        },
+pub fn try_rename_dir(old_name: impl AsRef<Path>, new_name: impl AsRef<Path>) -> bool {
+    #[track_caller]
+    fn f(old_name: &Path, new_name: &Path) -> bool {
+        match fs::create_dir(new_name) {
+            Ok(()) => {},
+            Err(e) if matches!(e.kind(), io::ErrorKind::AlreadyExists | io::ErrorKind::NotFound) => return false,
+            Err(ref e) => panic_action(e, ErrAction::Create, new_name),
+        }
+        // Windows can't reliably rename to an empty directory.
+        #[cfg(windows)]
+        drop(fs::remove_dir(new_name));
+        match fs::rename(old_name, new_name) {
+            Ok(()) => true,
+            Err(ref e) => {
+                // Already dropped earlier on windows.
+                #[cfg(not(windows))]
+                drop(fs::remove_dir(new_name));
+                // `NotADirectory` happens on posix when renaming a file to an existing directory.
+                if matches!(e.kind(), io::ErrorKind::NotFound | io::ErrorKind::NotADirectory) {
+                    false
+                } else {
+                    panic_action(e, ErrAction::Rename, old_name);
+                }
+            },
+        }
     }
+    f(old_name.as_ref(), new_name.as_ref())
 }
 
 #[track_caller]
@@ -575,21 +620,29 @@ pub fn split_args_for_threads(
 }
 
 #[track_caller]
-pub fn delete_file_if_exists(path: &Path) -> bool {
-    match fs::remove_file(path) {
-        Ok(()) => true,
-        Err(e) if matches!(e.kind(), io::ErrorKind::NotFound | io::ErrorKind::IsADirectory) => false,
-        Err(ref e) => panic_action(e, ErrAction::Delete, path),
+pub fn delete_file_if_exists(path: impl AsRef<Path>) -> bool {
+    #[track_caller]
+    fn f(path: &Path) -> bool {
+        match fs::remove_file(path) {
+            Ok(()) => true,
+            Err(e) if matches!(e.kind(), io::ErrorKind::NotFound | io::ErrorKind::IsADirectory) => false,
+            Err(ref e) => panic_action(e, ErrAction::Delete, path),
+        }
     }
+    f(path.as_ref())
 }
 
 #[track_caller]
-pub fn delete_dir_if_exists(path: &Path) {
-    match fs::remove_dir_all(path) {
-        Ok(()) => {},
-        Err(e) if matches!(e.kind(), io::ErrorKind::NotFound | io::ErrorKind::NotADirectory) => {},
-        Err(ref e) => panic_action(e, ErrAction::Delete, path),
+pub fn delete_dir_if_exists(path: impl AsRef<Path>) {
+    #[track_caller]
+    fn f(path: &Path) {
+        match fs::remove_dir_all(path) {
+            Ok(()) => {},
+            Err(e) if matches!(e.kind(), io::ErrorKind::NotFound | io::ErrorKind::NotADirectory) => {},
+            Err(ref e) => panic_action(e, ErrAction::Delete, path),
+        }
     }
+    f(path.as_ref());
 }
 
 /// Walks all items excluding top-level dot files/directories and any target directories.
@@ -600,3 +653,226 @@ pub fn walk_dir_no_dot_or_target(p: impl AsRef<Path>) -> impl Iterator<Item = ::
             .is_none_or(|x| x != "target" && x.as_encoded_bytes().first().copied() != Some(b'.'))
     })
 }
+
+pub fn slice_groups<T>(slice: &[T], split_idx: impl FnMut(&T, &[T]) -> usize) -> impl Iterator<Item = &[T]> {
+    struct I<'a, T, F> {
+        slice: &'a [T],
+        split_idx: F,
+    }
+    impl<'a, T, F: FnMut(&T, &[T]) -> usize> Iterator for I<'a, T, F> {
+        type Item = &'a [T];
+        fn next(&mut self) -> Option<Self::Item> {
+            let (head, tail) = self.slice.split_first()?;
+            let idx = (self.split_idx)(head, tail) + 1;
+            if let Some((head, tail)) = self.slice.split_at_checked(idx) {
+                self.slice = tail;
+                Some(head)
+            } else {
+                self.slice = &mut [];
+                None
+            }
+        }
+    }
+    I { slice, split_idx }
+}
+
+pub fn slice_groups_mut<T>(
+    slice: &mut [T],
+    split_idx: impl FnMut(&T, &[T]) -> usize,
+) -> impl Iterator<Item = &mut [T]> {
+    struct I<'a, T, F> {
+        slice: &'a mut [T],
+        split_idx: F,
+    }
+    impl<'a, T, F: FnMut(&T, &[T]) -> usize> Iterator for I<'a, T, F> {
+        type Item = &'a mut [T];
+        fn next(&mut self) -> Option<Self::Item> {
+            let (head, tail) = self.slice.split_first()?;
+            let idx = (self.split_idx)(head, tail) + 1;
+            // `mem::take` makes it so `self.slice` isn't reborrowed.
+            if let Some((head, tail)) = mem::take(&mut self.slice).split_at_mut_checked(idx) {
+                self.slice = tail;
+                Some(head)
+            } else {
+                self.slice = &mut [];
+                None
+            }
+        }
+    }
+    I { slice, split_idx }
+}
+
+/// A string used as a temporary buffer used to avoid allocating for short lived strings.
+pub struct StrBuf(String);
+impl StrBuf {
+    /// Creates a new buffer with the specified initial capacity.
+    pub fn with_capacity(cap: usize) -> Self {
+        Self(String::with_capacity(cap))
+    }
+
+    /// Allocates the result of formatting the given value onto the arena.
+    pub fn alloc_display<'cx>(&mut self, arena: &'cx DroplessArena, value: impl Display) -> &'cx str {
+        self.0.clear();
+        write!(self.0, "{value}").expect("`Display` impl returned an error");
+        if self.0.is_empty() {
+            ""
+        } else {
+            arena.alloc_str(&self.0)
+        }
+    }
+
+    /// Allocates the string onto the arena with all ascii characters converted to
+    /// lowercase.
+    pub fn alloc_ascii_lower<'cx>(&mut self, arena: &'cx DroplessArena, s: &str) -> &'cx str {
+        self.0.clear();
+        self.0.push_str(s);
+        self.0.make_ascii_lowercase();
+        if self.0.is_empty() {
+            ""
+        } else {
+            arena.alloc_str(&self.0)
+        }
+    }
+
+    /// Collects all elements into the buffer and allocates that onto the arena.
+    pub fn alloc_collect<'cx, I>(&mut self, arena: &'cx DroplessArena, iter: I) -> &'cx str
+    where
+        I: IntoIterator,
+        String: Extend<I::Item>,
+    {
+        self.0.clear();
+        self.0.extend(iter);
+        if self.0.is_empty() {
+            ""
+        } else {
+            arena.alloc_str(&self.0)
+        }
+    }
+
+    /// Allocates the result of replacing all instances the pattern with the given string
+    /// onto the arena.
+    pub fn alloc_replaced<'cx>(
+        &mut self,
+        arena: &'cx DroplessArena,
+        s: &str,
+        pat: impl Pattern,
+        replacement: &str,
+    ) -> &'cx str {
+        let mut parts = s.split(pat);
+        let Some(first) = parts.next() else {
+            return "";
+        };
+        self.0.clear();
+        self.0.push_str(first);
+        for part in parts {
+            self.0.push_str(replacement);
+            self.0.push_str(part);
+        }
+        if self.0.is_empty() {
+            ""
+        } else {
+            arena.alloc_str(&self.0)
+        }
+    }
+
+    /// Performs an operation with the freshly cleared buffer.
+    pub fn with<T>(&mut self, f: impl FnOnce(&mut String) -> T) -> T {
+        self.0.clear();
+        f(&mut self.0)
+    }
+}
+
+pub struct VecBuf<T>(Vec<T>);
+impl<T> VecBuf<T> {
+    /// Creates a new buffer with the specified initial capacity.
+    pub fn with_capacity(cap: usize) -> Self {
+        Self(Vec::with_capacity(cap))
+    }
+
+    /// Performs an operation with the freshly cleared buffer.
+    pub fn with<R>(&mut self, f: impl FnOnce(&mut Vec<T>) -> R) -> R {
+        self.0.clear();
+        f(&mut self.0)
+    }
+}
+
+#[derive(Eq)]
+pub struct SourceFile<'cx> {
+    // `cargo dev rename_lint` needs to be able to rename files.
+    pub path: Cell<&'cx str>,
+    pub line_starts: OnceCell<Vec<u32>>,
+    pub contents: String,
+}
+impl<'cx> SourceFile<'cx> {
+    #[must_use]
+    pub fn load(path: &'cx str) -> Self {
+        let mut contents = String::new();
+        File::open_read(path).read_append_to_string(&mut contents);
+        SourceFile {
+            path: Cell::new(path),
+            line_starts: OnceCell::new(),
+            contents,
+        }
+    }
+
+    pub fn line_starts(&self) -> &[u32] {
+        self.line_starts.get_or_init(|| {
+            let mut line_starts = Vec::with_capacity(self.contents.len() / 32 + 4);
+            line_starts.push(0);
+            #[expect(clippy::cast_possible_truncation)]
+            line_starts.extend(memchr_iter(b'\n', self.contents.as_bytes()).map(|x| x as u32 + 1));
+            line_starts
+        })
+    }
+
+    /// Splits the file's path into the crate it's a part of and the module it implements.
+    ///
+    /// Only supports paths in the form `CRATE_NAME/src/PATH/TO/FILE.rs` using the current
+    /// platform's path separator. The module path returned will use the current platform's
+    /// path separator.
+    pub fn path_as_krate_mod(&self) -> (&'cx str, &'cx str) {
+        let path = self.path.get();
+        let Some((krate, path)) = path.split_once(path::MAIN_SEPARATOR) else {
+            return ("", "");
+        };
+        let module = if let Some(path) = path.strip_prefix("src")
+            && let Some(path) = path.strip_prefix(path::MAIN_SEPARATOR)
+            && let Some(path) = path.strip_suffix(".rs")
+        {
+            if path == "lib" {
+                ""
+            } else if let Some(path) = path.strip_suffix("mod")
+                && let Some(path) = path.strip_suffix(path::MAIN_SEPARATOR)
+            {
+                path
+            } else {
+                path
+            }
+        } else {
+            ""
+        };
+        (krate, module)
+    }
+}
+impl PartialEq<SourceFile<'_>> for SourceFile<'_> {
+    fn eq(&self, other: &SourceFile<'_>) -> bool {
+        // We should only be creating one source file per path.
+        ptr::addr_eq(self, other)
+    }
+}
+impl Hash for SourceFile<'_> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        ptr::hash(self, state);
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct Span<'cx> {
+    pub file: &'cx SourceFile<'cx>,
+    pub range: Range<u32>,
+}
+impl<'cx> Span<'cx> {
+    pub fn new(file: &'cx SourceFile<'cx>, range: Range<u32>) -> Self {
+        Self { file, range }
+    }
+}
diff --git a/clippy_lints/src/absolute_paths.rs b/clippy_lints/src/absolute_paths.rs
index 1af6d448a93c..fd515939dfb8 100644
--- a/clippy_lints/src/absolute_paths.rs
+++ b/clippy_lints/src/absolute_paths.rs
@@ -52,6 +52,7 @@ declare_clippy_lint! {
     restriction,
     "checks for usage of an item without a `use` statement"
 }
+
 impl_lint_pass!(AbsolutePaths => [ABSOLUTE_PATHS]);
 
 pub struct AbsolutePaths {
diff --git a/clippy_lints/src/almost_complete_range.rs b/clippy_lints/src/almost_complete_range.rs
index 4f55968d5625..258970393023 100644
--- a/clippy_lints/src/almost_complete_range.rs
+++ b/clippy_lints/src/almost_complete_range.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     suspicious,
     "almost complete range"
 }
+
 impl_lint_pass!(AlmostCompleteRange => [ALMOST_COMPLETE_RANGE]);
 
 pub struct AlmostCompleteRange {
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index a3710ca51655..2ea921e5d461 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -39,6 +39,8 @@ declare_clippy_lint! {
     "the approximate of a known float constant (in `std::fXX::consts`)"
 }
 
+impl_lint_pass!(ApproxConstant => [APPROX_CONSTANT]);
+
 // Tuples are of the form (constant, name, min_digits, msrv)
 const KNOWN_CONSTS: [(f64, &str, usize, Option<RustcVersion>); 19] = [
     (f64::E, "E", 4, None),
@@ -111,8 +113,6 @@ impl ApproxConstant {
     }
 }
 
-impl_lint_pass!(ApproxConstant => [APPROX_CONSTANT]);
-
 fn count_digits_after_dot(input: &str) -> usize {
     input
         .char_indices()
diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index acfdfa65baed..e449b06199d3 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     suspicious,
     "using `Arc` with a type that does not implement `Send` and `Sync`"
 }
+
 declare_lint_pass!(ArcWithNonSendSync => [ARC_WITH_NON_SEND_SYNC]);
 
 impl<'tcx> LateLintPass<'tcx> for ArcWithNonSendSync {
diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
index 69a8eb7d94e7..3c5cf74d5a17 100644
--- a/clippy_lints/src/asm_syntax.rs
+++ b/clippy_lints/src/asm_syntax.rs
@@ -59,10 +59,10 @@ fn check_asm_syntax(
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of Intel x86 assembly syntax.
+    /// Checks for usage of AT&T x86 assembly syntax.
     ///
     /// ### Why restrict this?
-    /// To enforce consistent use of AT&T x86 assembly syntax.
+    /// To enforce consistent use of Intel x86 assembly syntax.
     ///
     /// ### Example
     ///
@@ -71,7 +71,7 @@ declare_clippy_lint! {
     /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     /// # unsafe { let ptr = "".as_ptr();
     /// # use std::arch::asm;
-    /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
+    /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
     /// # }
     /// ```
     /// Use instead:
@@ -80,37 +80,21 @@ declare_clippy_lint! {
     /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     /// # unsafe { let ptr = "".as_ptr();
     /// # use std::arch::asm;
-    /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
+    /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
     /// # }
     /// ```
     #[clippy::version = "1.49.0"]
-    pub INLINE_ASM_X86_INTEL_SYNTAX,
+    pub INLINE_ASM_X86_ATT_SYNTAX,
     restriction,
-    "prefer AT&T x86 assembly syntax"
-}
-
-declare_lint_pass!(InlineAsmX86IntelSyntax => [INLINE_ASM_X86_INTEL_SYNTAX]);
-
-impl EarlyLintPass for InlineAsmX86IntelSyntax {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
-            check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, expr.span, AsmStyle::Intel);
-        }
-    }
-
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if let ItemKind::GlobalAsm(inline_asm) = &item.kind {
-            check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, item.span, AsmStyle::Intel);
-        }
-    }
+    "prefer Intel x86 assembly syntax"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of AT&T x86 assembly syntax.
+    /// Checks for usage of Intel x86 assembly syntax.
     ///
     /// ### Why restrict this?
-    /// To enforce consistent use of Intel x86 assembly syntax.
+    /// To enforce consistent use of AT&T x86 assembly syntax.
     ///
     /// ### Example
     ///
@@ -119,7 +103,7 @@ declare_clippy_lint! {
     /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     /// # unsafe { let ptr = "".as_ptr();
     /// # use std::arch::asm;
-    /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
+    /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
     /// # }
     /// ```
     /// Use instead:
@@ -128,17 +112,33 @@ declare_clippy_lint! {
     /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     /// # unsafe { let ptr = "".as_ptr();
     /// # use std::arch::asm;
-    /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
+    /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
     /// # }
     /// ```
     #[clippy::version = "1.49.0"]
-    pub INLINE_ASM_X86_ATT_SYNTAX,
+    pub INLINE_ASM_X86_INTEL_SYNTAX,
     restriction,
-    "prefer Intel x86 assembly syntax"
+    "prefer AT&T x86 assembly syntax"
 }
 
 declare_lint_pass!(InlineAsmX86AttSyntax => [INLINE_ASM_X86_ATT_SYNTAX]);
 
+declare_lint_pass!(InlineAsmX86IntelSyntax => [INLINE_ASM_X86_INTEL_SYNTAX]);
+
+impl EarlyLintPass for InlineAsmX86IntelSyntax {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
+            check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, expr.span, AsmStyle::Intel);
+        }
+    }
+
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if let ItemKind::GlobalAsm(inline_asm) = &item.kind {
+            check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, item.span, AsmStyle::Intel);
+        }
+    }
+}
+
 impl EarlyLintPass for InlineAsmX86AttSyntax {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 4aa55e53445c..6e57d0608bed 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
 }
 
 impl_lint_pass!(AssertionsOnConstants => [ASSERTIONS_ON_CONSTANTS]);
+
 pub struct AssertionsOnConstants {
     msrv: Msrv,
 }
diff --git a/clippy_lints/src/assigning_clones.rs b/clippy_lints/src/assigning_clones.rs
index efce23d13a38..60bc9b2b5b85 100644
--- a/clippy_lints/src/assigning_clones.rs
+++ b/clippy_lints/src/assigning_clones.rs
@@ -53,6 +53,8 @@ declare_clippy_lint! {
     "assigning the result of cloning may be inefficient"
 }
 
+impl_lint_pass!(AssigningClones => [ASSIGNING_CLONES]);
+
 pub struct AssigningClones {
     msrv: Msrv,
 }
@@ -63,8 +65,6 @@ impl AssigningClones {
     }
 }
 
-impl_lint_pass!(AssigningClones => [ASSIGNING_CLONES]);
-
 impl<'tcx> LateLintPass<'tcx> for AssigningClones {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if let ExprKind::Assign(lhs, rhs, _) = e.kind
diff --git a/clippy_lints/src/attrs/mod.rs b/clippy_lints/src/attrs/mod.rs
index fa2951d91934..c15a378053e3 100644
--- a/clippy_lints/src/attrs/mod.rs
+++ b/clippy_lints/src/attrs/mod.rs
@@ -25,106 +25,60 @@ use utils::{is_lint_level, is_relevant_impl, is_relevant_item, is_relevant_trait
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for items annotated with `#[inline(always)]`,
-    /// unless the annotated function is empty or simply panics.
-    ///
-    /// ### Why is this bad?
-    /// While there are valid uses of this annotation (and once
-    /// you know when to use it, by all means `allow` this lint), it's a common
-    /// newbie-mistake to pepper one's code with it.
-    ///
-    /// As a rule of thumb, before slapping `#[inline(always)]` on a function,
-    /// measure if that additional function call really affects your runtime profile
-    /// sufficiently to make up for the increase in compile time.
-    ///
-    /// ### Known problems
-    /// False positives, big time. This lint is meant to be
-    /// deactivated by everyone doing serious performance work. This means having
-    /// done the measurement.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// #[inline(always)]
-    /// fn not_quite_hot_code(..) { ... }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub INLINE_ALWAYS,
-    pedantic,
-    "use of `#[inline(always)]`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `extern crate` and `use` items annotated with
-    /// lint attributes.
-    ///
-    /// This lint permits lint attributes for lints emitted on the items themself.
-    /// For `use` items these lints are:
-    /// * ambiguous_glob_reexports
-    /// * dead_code
-    /// * deprecated
-    /// * hidden_glob_reexports
-    /// * unreachable_pub
-    /// * unused
-    /// * unused_braces
-    /// * unused_import_braces
-    /// * clippy::disallowed_types
-    /// * clippy::enum_glob_use
-    /// * clippy::macro_use_imports
-    /// * clippy::module_name_repetitions
-    /// * clippy::redundant_pub_crate
-    /// * clippy::single_component_path_imports
-    /// * clippy::unsafe_removed_from_name
-    /// * clippy::wildcard_imports
+    /// Checks for usage of the `#[allow]` attribute and suggests replacing it with
+    /// the `#[expect]` attribute (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
     ///
-    /// For `extern crate` items these lints are:
-    /// * `unused_imports` on items with `#[macro_use]`
+    /// This lint only warns outer attributes (`#[allow]`), as inner attributes
+    /// (`#![allow]`) are usually used to enable or disable lints on a global scale.
     ///
     /// ### Why is this bad?
-    /// Lint attributes have no effect on crate imports. Most
-    /// likely a `!` was forgotten.
+    /// `#[expect]` attributes suppress the lint emission, but emit a warning, if
+    /// the expectation is unfulfilled. This can be useful to be notified when the
+    /// lint is no longer triggered.
     ///
     /// ### Example
-    /// ```ignore
-    /// #[deny(dead_code)]
-    /// extern crate foo;
-    /// #[forbid(dead_code)]
-    /// use foo::bar;
+    /// ```rust,ignore
+    /// #[allow(unused_mut)]
+    /// fn foo() -> usize {
+    ///     let mut a = Vec::new();
+    ///     a.len()
+    /// }
     /// ```
-    ///
     /// Use instead:
     /// ```rust,ignore
-    /// #[allow(unused_imports)]
-    /// use foo::baz;
-    /// #[allow(unused_imports)]
-    /// #[macro_use]
-    /// extern crate baz;
+    /// #[expect(unused_mut)]
+    /// fn foo() -> usize {
+    ///     let mut a = Vec::new();
+    ///     a.len()
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub USELESS_ATTRIBUTE,
-    correctness,
-    "use of lint attributes on `extern crate` items"
+    #[clippy::version = "1.70.0"]
+    pub ALLOW_ATTRIBUTES,
+    restriction,
+    "`#[allow]` will not trigger if a warning isn't found. `#[expect]` triggers if there are no warnings."
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `#[deprecated]` annotations with a `since`
-    /// field that is not a valid semantic version. Also allows "TBD" to signal
-    /// future deprecation.
+    /// Checks for attributes that allow lints without a reason.
     ///
-    /// ### Why is this bad?
-    /// For checking the version of the deprecation, it must be
-    /// a valid semver. Failing that, the contained information is useless.
+    /// ### Why restrict this?
+    /// Justifying each `allow` helps readers understand the reasoning,
+    /// and may allow removing `allow` attributes if their purpose is obsolete.
     ///
     /// ### Example
     /// ```no_run
-    /// #[deprecated(since = "forever")]
-    /// fn something_else() { /* ... */ }
+    /// #![allow(clippy::some_lint)]
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DEPRECATED_SEMVER,
-    correctness,
-    "use of `#[deprecated(since = \"x\")]` where x is not semver"
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// #![allow(clippy::some_lint, reason = "False positive rust-lang/rust-clippy#1002020")]
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub ALLOW_ATTRIBUTES_WITHOUT_REASON,
+    restriction,
+    "ensures that all `allow` and `expect` attributes have a reason"
 }
 
 declare_clippy_lint! {
@@ -183,95 +137,195 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for attributes that allow lints without a reason.
+    /// Checks for `#[cfg_attr(feature = "cargo-clippy", ...)]` and for
+    /// `#[cfg(feature = "cargo-clippy")]` and suggests to replace it with
+    /// `#[cfg_attr(clippy, ...)]` or `#[cfg(clippy)]`.
     ///
-    /// ### Why restrict this?
-    /// Justifying each `allow` helps readers understand the reasoning,
-    /// and may allow removing `allow` attributes if their purpose is obsolete.
+    /// ### Why is this bad?
+    /// This feature has been deprecated for years and shouldn't be used anymore.
     ///
     /// ### Example
     /// ```no_run
-    /// #![allow(clippy::some_lint)]
+    /// #[cfg(feature = "cargo-clippy")]
+    /// struct Bar;
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// #![allow(clippy::some_lint, reason = "False positive rust-lang/rust-clippy#1002020")]
+    /// #[cfg(clippy)]
+    /// struct Bar;
     /// ```
-    #[clippy::version = "1.61.0"]
-    pub ALLOW_ATTRIBUTES_WITHOUT_REASON,
-    restriction,
-    "ensures that all `allow` and `expect` attributes have a reason"
+    #[clippy::version = "1.78.0"]
+    pub DEPRECATED_CLIPPY_CFG_ATTR,
+    suspicious,
+    "usage of `cfg(feature = \"cargo-clippy\")` instead of `cfg(clippy)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of the `#[allow]` attribute and suggests replacing it with
-    /// the `#[expect]` attribute (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
+    /// Checks for `#[deprecated]` annotations with a `since`
+    /// field that is not a valid semantic version. Also allows "TBD" to signal
+    /// future deprecation.
     ///
-    /// This lint only warns outer attributes (`#[allow]`), as inner attributes
-    /// (`#![allow]`) are usually used to enable or disable lints on a global scale.
+    /// ### Why is this bad?
+    /// For checking the version of the deprecation, it must be
+    /// a valid semver. Failing that, the contained information is useless.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[deprecated(since = "forever")]
+    /// fn something_else() { /* ... */ }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DEPRECATED_SEMVER,
+    correctness,
+    "use of `#[deprecated(since = \"x\")]` where x is not semver"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for attributes that appear two or more times.
     ///
     /// ### Why is this bad?
-    /// `#[expect]` attributes suppress the lint emission, but emit a warning, if
-    /// the expectation is unfulfilled. This can be useful to be notified when the
-    /// lint is no longer triggered.
+    /// Repeating an attribute on the same item (or globally on the same crate)
+    /// is unnecessary and doesn't have an effect.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// #[allow(unused_mut)]
-    /// fn foo() -> usize {
-    ///     let mut a = Vec::new();
-    ///     a.len()
-    /// }
+    /// ```no_run
+    /// #[allow(dead_code)]
+    /// #[allow(dead_code)]
+    /// fn foo() {}
     /// ```
+    ///
     /// Use instead:
-    /// ```rust,ignore
-    /// #[expect(unused_mut)]
-    /// fn foo() -> usize {
-    ///     let mut a = Vec::new();
-    ///     a.len()
+    /// ```no_run
+    /// #[allow(dead_code)]
+    /// fn foo() {}
+    /// ```
+    #[clippy::version = "1.79.0"]
+    pub DUPLICATED_ATTRIBUTES,
+    suspicious,
+    "duplicated attribute"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for ignored tests without messages.
+    ///
+    /// ### Why is this bad?
+    /// The reason for ignoring the test may not be obvious.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[test]
+    /// #[ignore]
+    /// fn test() {}
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #[test]
+    /// #[ignore = "Some good reason"]
+    /// fn test() {}
+    /// ```
+    ///
+    /// ### Note
+    /// Clippy can only lint compiled code. For this lint to trigger, you must configure `cargo clippy`
+    /// to include test compilation, for instance, by using flags such as `--tests` or `--all-targets`.
+    #[clippy::version = "1.88.0"]
+    pub IGNORE_WITHOUT_REASON,
+    pedantic,
+    "ignored tests without messages"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for items annotated with `#[inline(always)]`,
+    /// unless the annotated function is empty or simply panics.
+    ///
+    /// ### Why is this bad?
+    /// While there are valid uses of this annotation (and once
+    /// you know when to use it, by all means `allow` this lint), it's a common
+    /// newbie-mistake to pepper one's code with it.
+    ///
+    /// As a rule of thumb, before slapping `#[inline(always)]` on a function,
+    /// measure if that additional function call really affects your runtime profile
+    /// sufficiently to make up for the increase in compile time.
+    ///
+    /// ### Known problems
+    /// False positives, big time. This lint is meant to be
+    /// deactivated by everyone doing serious performance work. This means having
+    /// done the measurement.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// #[inline(always)]
+    /// fn not_quite_hot_code(..) { ... }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub INLINE_ALWAYS,
+    pedantic,
+    "use of `#[inline(always)]`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for items that have the same kind of attributes with mixed styles (inner/outer).
+    ///
+    /// ### Why is this bad?
+    /// Having both style of said attributes makes it more complicated to read code.
+    ///
+    /// ### Known problems
+    /// This lint currently has false-negatives when mixing same attributes
+    /// but they have different path symbols, for example:
+    /// ```ignore
+    /// #[custom_attribute]
+    /// pub fn foo() {
+    ///     #![my_crate::custom_attribute]
+    /// }
+    /// ```
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[cfg(linux)]
+    /// pub fn foo() {
+    ///     #![cfg(windows)]
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #[cfg(linux)]
+    /// #[cfg(windows)]
+    /// pub fn foo() {
     /// }
     /// ```
-    #[clippy::version = "1.70.0"]
-    pub ALLOW_ATTRIBUTES,
-    restriction,
-    "`#[allow]` will not trigger if a warning isn't found. `#[expect]` triggers if there are no warnings."
+    #[clippy::version = "1.78.0"]
+    pub MIXED_ATTRIBUTES_STYLE,
+    style,
+    "item has both inner and outer attributes"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `#[should_panic]` attributes without specifying the expected panic message.
+    /// Checks for `any` and `all` combinators in `cfg` with only one condition.
     ///
     /// ### Why is this bad?
-    /// The expected panic message should be specified to ensure that the test is actually
-    /// panicking with the expected message, and not another unrelated panic.
+    /// If there is only one condition, no need to wrap it into `any` or `all` combinators.
     ///
     /// ### Example
     /// ```no_run
-    /// fn random() -> i32 { 0 }
-    ///
-    /// #[should_panic]
-    /// #[test]
-    /// fn my_test() {
-    ///     let _ = 1 / random();
-    /// }
+    /// #[cfg(any(unix))]
+    /// pub struct Bar;
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// fn random() -> i32 { 0 }
-    ///
-    /// #[should_panic = "attempt to divide by zero"]
-    /// #[test]
-    /// fn my_test() {
-    ///     let _ = 1 / random();
-    /// }
+    /// #[cfg(unix)]
+    /// pub struct Bar;
     /// ```
-    #[clippy::version = "1.74.0"]
-    pub SHOULD_PANIC_WITHOUT_EXPECT,
-    pedantic,
-    "ensures that all `should_panic` attributes specify its expected panic message"
+    #[clippy::version = "1.71.0"]
+    pub NON_MINIMAL_CFG,
+    style,
+    "ensure that all `cfg(any())` and `cfg(all())` have more than one condition"
 }
 
 declare_clippy_lint! {
@@ -314,52 +368,37 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `any` and `all` combinators in `cfg` with only one condition.
+    /// Checks for `#[should_panic]` attributes without specifying the expected panic message.
     ///
     /// ### Why is this bad?
-    /// If there is only one condition, no need to wrap it into `any` or `all` combinators.
+    /// The expected panic message should be specified to ensure that the test is actually
+    /// panicking with the expected message, and not another unrelated panic.
     ///
     /// ### Example
     /// ```no_run
-    /// #[cfg(any(unix))]
-    /// pub struct Bar;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// #[cfg(unix)]
-    /// pub struct Bar;
-    /// ```
-    #[clippy::version = "1.71.0"]
-    pub NON_MINIMAL_CFG,
-    style,
-    "ensure that all `cfg(any())` and `cfg(all())` have more than one condition"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `#[cfg_attr(feature = "cargo-clippy", ...)]` and for
-    /// `#[cfg(feature = "cargo-clippy")]` and suggests to replace it with
-    /// `#[cfg_attr(clippy, ...)]` or `#[cfg(clippy)]`.
-    ///
-    /// ### Why is this bad?
-    /// This feature has been deprecated for years and shouldn't be used anymore.
+    /// fn random() -> i32 { 0 }
     ///
-    /// ### Example
-    /// ```no_run
-    /// #[cfg(feature = "cargo-clippy")]
-    /// struct Bar;
+    /// #[should_panic]
+    /// #[test]
+    /// fn my_test() {
+    ///     let _ = 1 / random();
+    /// }
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// #[cfg(clippy)]
-    /// struct Bar;
+    /// fn random() -> i32 { 0 }
+    ///
+    /// #[should_panic = "attempt to divide by zero"]
+    /// #[test]
+    /// fn my_test() {
+    ///     let _ = 1 / random();
+    /// }
     /// ```
-    #[clippy::version = "1.78.0"]
-    pub DEPRECATED_CLIPPY_CFG_ATTR,
-    suspicious,
-    "usage of `cfg(feature = \"cargo-clippy\")` instead of `cfg(clippy)`"
+    #[clippy::version = "1.74.0"]
+    pub SHOULD_PANIC_WITHOUT_EXPECT,
+    pedantic,
+    "ensures that all `should_panic` attributes specify its expected panic message"
 }
 
 declare_clippy_lint! {
@@ -388,105 +427,82 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for items that have the same kind of attributes with mixed styles (inner/outer).
-    ///
-    /// ### Why is this bad?
-    /// Having both style of said attributes makes it more complicated to read code.
+    /// Checks for `extern crate` and `use` items annotated with
+    /// lint attributes.
     ///
-    /// ### Known problems
-    /// This lint currently has false-negatives when mixing same attributes
-    /// but they have different path symbols, for example:
-    /// ```ignore
-    /// #[custom_attribute]
-    /// pub fn foo() {
-    ///     #![my_crate::custom_attribute]
-    /// }
-    /// ```
+    /// This lint permits lint attributes for lints emitted on the items themself.
+    /// For `use` items these lints are:
+    /// * ambiguous_glob_reexports
+    /// * dead_code
+    /// * deprecated
+    /// * hidden_glob_reexports
+    /// * unreachable_pub
+    /// * unused
+    /// * unused_braces
+    /// * unused_import_braces
+    /// * clippy::disallowed_types
+    /// * clippy::enum_glob_use
+    /// * clippy::macro_use_imports
+    /// * clippy::module_name_repetitions
+    /// * clippy::redundant_pub_crate
+    /// * clippy::single_component_path_imports
+    /// * clippy::unsafe_removed_from_name
+    /// * clippy::wildcard_imports
     ///
-    /// ### Example
-    /// ```no_run
-    /// #[cfg(linux)]
-    /// pub fn foo() {
-    ///     #![cfg(windows)]
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// #[cfg(linux)]
-    /// #[cfg(windows)]
-    /// pub fn foo() {
-    /// }
-    /// ```
-    #[clippy::version = "1.78.0"]
-    pub MIXED_ATTRIBUTES_STYLE,
-    style,
-    "item has both inner and outer attributes"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for attributes that appear two or more times.
+    /// For `extern crate` items these lints are:
+    /// * `unused_imports` on items with `#[macro_use]`
     ///
     /// ### Why is this bad?
-    /// Repeating an attribute on the same item (or globally on the same crate)
-    /// is unnecessary and doesn't have an effect.
+    /// Lint attributes have no effect on crate imports. Most
+    /// likely a `!` was forgotten.
     ///
     /// ### Example
-    /// ```no_run
-    /// #[allow(dead_code)]
-    /// #[allow(dead_code)]
-    /// fn foo() {}
+    /// ```ignore
+    /// #[deny(dead_code)]
+    /// extern crate foo;
+    /// #[forbid(dead_code)]
+    /// use foo::bar;
     /// ```
     ///
     /// Use instead:
-    /// ```no_run
-    /// #[allow(dead_code)]
-    /// fn foo() {}
+    /// ```rust,ignore
+    /// #[allow(unused_imports)]
+    /// use foo::baz;
+    /// #[allow(unused_imports)]
+    /// #[macro_use]
+    /// extern crate baz;
     /// ```
-    #[clippy::version = "1.79.0"]
-    pub DUPLICATED_ATTRIBUTES,
-    suspicious,
-    "duplicated attribute"
+    #[clippy::version = "pre 1.29.0"]
+    pub USELESS_ATTRIBUTE,
+    correctness,
+    "use of lint attributes on `extern crate` items"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for ignored tests without messages.
-    ///
-    /// ### Why is this bad?
-    /// The reason for ignoring the test may not be obvious.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[test]
-    /// #[ignore]
-    /// fn test() {}
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// #[test]
-    /// #[ignore = "Some good reason"]
-    /// fn test() {}
-    /// ```
-    ///
-    /// ### Note
-    /// Clippy can only lint compiled code. For this lint to trigger, you must configure `cargo clippy`
-    /// to include test compilation, for instance, by using flags such as `--tests` or `--all-targets`.
-    #[clippy::version = "1.88.0"]
-    pub IGNORE_WITHOUT_REASON,
-    pedantic,
-    "ignored tests without messages"
-}
+impl_lint_pass!(Attributes => [INLINE_ALWAYS, REPR_PACKED_WITHOUT_ABI]);
+
+impl_lint_pass!(EarlyAttributes => [
+    DEPRECATED_CFG_ATTR,
+    DEPRECATED_CLIPPY_CFG_ATTR,
+    NON_MINIMAL_CFG,
+    UNNECESSARY_CLIPPY_CFG,
+]);
+
+impl_lint_pass!(PostExpansionEarlyAttributes => [
+    ALLOW_ATTRIBUTES,
+    ALLOW_ATTRIBUTES_WITHOUT_REASON,
+    BLANKET_CLIPPY_RESTRICTION_LINTS,
+    DEPRECATED_SEMVER,
+    DUPLICATED_ATTRIBUTES,
+    IGNORE_WITHOUT_REASON,
+    MIXED_ATTRIBUTES_STYLE,
+    SHOULD_PANIC_WITHOUT_EXPECT,
+    USELESS_ATTRIBUTE,
+]);
 
 pub struct Attributes {
     msrv: Msrv,
 }
 
-impl_lint_pass!(Attributes => [
-    INLINE_ALWAYS,
-    REPR_PACKED_WITHOUT_ABI,
-]);
-
 impl Attributes {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
@@ -529,13 +545,6 @@ impl EarlyAttributes {
     }
 }
 
-impl_lint_pass!(EarlyAttributes => [
-    DEPRECATED_CFG_ATTR,
-    NON_MINIMAL_CFG,
-    DEPRECATED_CLIPPY_CFG_ATTR,
-    UNNECESSARY_CLIPPY_CFG,
-]);
-
 impl EarlyLintPass for EarlyAttributes {
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
         deprecated_cfg_attr::check(cx, attr, &self.msrv);
@@ -558,18 +567,6 @@ impl PostExpansionEarlyAttributes {
     }
 }
 
-impl_lint_pass!(PostExpansionEarlyAttributes => [
-    ALLOW_ATTRIBUTES,
-    ALLOW_ATTRIBUTES_WITHOUT_REASON,
-    DEPRECATED_SEMVER,
-    IGNORE_WITHOUT_REASON,
-    USELESS_ATTRIBUTE,
-    BLANKET_CLIPPY_RESTRICTION_LINTS,
-    SHOULD_PANIC_WITHOUT_EXPECT,
-    MIXED_ATTRIBUTES_STYLE,
-    DUPLICATED_ATTRIBUTES,
-]);
-
 impl EarlyLintPass for PostExpansionEarlyAttributes {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &ast::Crate) {
         blanket_clippy_restriction_lints::check_command_line(cx);
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 31cc004f6855..dbd7dbdd1c6f 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -10,6 +10,43 @@ use rustc_middle::ty::TyCtxt;
 use rustc_session::impl_lint_pass;
 use rustc_span::{Span, sym};
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Allows users to configure types which should not be held across await
+    /// suspension points.
+    ///
+    /// ### Why is this bad?
+    /// There are some types which are perfectly safe to use concurrently from
+    /// a memory access perspective, but that will cause bugs at runtime if
+    /// they are held in such a way.
+    ///
+    /// ### Example
+    ///
+    /// ```toml
+    /// await-holding-invalid-types = [
+    ///   # You can specify a type name
+    ///   "CustomLockType",
+    ///   # You can (optionally) specify a reason
+    ///   { path = "OtherCustomLockType", reason = "Relies on a thread local" }
+    /// ]
+    /// ```
+    ///
+    /// ```no_run
+    /// # async fn baz() {}
+    /// struct CustomLockType;
+    /// struct OtherCustomLockType;
+    /// async fn foo() {
+    ///   let _x = CustomLockType;
+    ///   let _y = OtherCustomLockType;
+    ///   baz().await; // Lint violation
+    /// }
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub AWAIT_HOLDING_INVALID_TYPE,
+    suspicious,
+    "holding a type across an await point which is not allowed to be held as per the configuration"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to `await` while holding a non-async-aware
@@ -134,44 +171,11 @@ declare_clippy_lint! {
     "inside an async function, holding a `RefCell` ref while calling `await`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Allows users to configure types which should not be held across await
-    /// suspension points.
-    ///
-    /// ### Why is this bad?
-    /// There are some types which are perfectly safe to use concurrently from
-    /// a memory access perspective, but that will cause bugs at runtime if
-    /// they are held in such a way.
-    ///
-    /// ### Example
-    ///
-    /// ```toml
-    /// await-holding-invalid-types = [
-    ///   # You can specify a type name
-    ///   "CustomLockType",
-    ///   # You can (optionally) specify a reason
-    ///   { path = "OtherCustomLockType", reason = "Relies on a thread local" }
-    /// ]
-    /// ```
-    ///
-    /// ```no_run
-    /// # async fn baz() {}
-    /// struct CustomLockType;
-    /// struct OtherCustomLockType;
-    /// async fn foo() {
-    ///   let _x = CustomLockType;
-    ///   let _y = OtherCustomLockType;
-    ///   baz().await; // Lint violation
-    /// }
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub AWAIT_HOLDING_INVALID_TYPE,
-    suspicious,
-    "holding a type across an await point which is not allowed to be held as per the configuration"
-}
-
-impl_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF, AWAIT_HOLDING_INVALID_TYPE]);
+impl_lint_pass!(AwaitHolding => [
+    AWAIT_HOLDING_INVALID_TYPE,
+    AWAIT_HOLDING_LOCK,
+    AWAIT_HOLDING_REFCELL_REF,
+]);
 
 pub struct AwaitHolding {
     def_ids: DefIdMap<(&'static str, &'static DisallowedPathWithoutReplacement)>,
diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index 129e77478406..b98a20a90ccb 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -43,6 +43,7 @@ declare_clippy_lint! {
     pedantic,
     "using if to convert bool to int"
 }
+
 declare_lint_pass!(BoolToIntWithIf => [BOOL_TO_INT_WITH_IF]);
 
 impl<'tcx> LateLintPass<'tcx> for BoolToIntWithIf {
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 0bd459d8b021..8b7619d11a83 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -74,6 +74,8 @@ declare_clippy_lint! {
     "boolean expressions that contain terminals which can be eliminated"
 }
 
+impl_lint_pass!(NonminimalBool => [NONMINIMAL_BOOL, OVERLY_COMPLEX_BOOL_EXPR]);
+
 // For each pairs, both orders are considered.
 const METHODS_WITH_NEGATION: [(Option<RustcVersion>, Symbol, Symbol); 3] = [
     (None, sym::is_some, sym::is_none),
@@ -91,8 +93,6 @@ impl NonminimalBool {
     }
 }
 
-impl_lint_pass!(NonminimalBool => [NONMINIMAL_BOOL, OVERLY_COMPLEX_BOOL_EXPR]);
-
 impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
     fn check_fn(
         &mut self,
diff --git a/clippy_lints/src/byte_char_slices.rs b/clippy_lints/src/byte_char_slices.rs
index fc9931439e93..6c023189f69e 100644
--- a/clippy_lints/src/byte_char_slices.rs
+++ b/clippy_lints/src/byte_char_slices.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     style,
     "hard to read byte char slice"
 }
+
 declare_lint_pass!(ByteCharSlice => [BYTE_CHAR_SLICES]);
 
 impl EarlyLintPass for ByteCharSlice {
diff --git a/clippy_lints/src/cargo/mod.rs b/clippy_lints/src/cargo/mod.rs
index 08d92adbacef..0aa6e4c3e8e2 100644
--- a/clippy_lints/src/cargo/mod.rs
+++ b/clippy_lints/src/cargo/mod.rs
@@ -58,34 +58,68 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for feature names with prefix `use-`, `with-` or suffix `-support`
+    /// Checks for lint groups with the same priority as lints in the `Cargo.toml`
+    /// [`[lints]` table](https://doc.rust-lang.org/cargo/reference/manifest.html#the-lints-section).
+    ///
+    /// This lint will be removed once [cargo#12918](https://github.com/rust-lang/cargo/issues/12918)
+    /// is resolved.
     ///
     /// ### Why is this bad?
-    /// These prefixes and suffixes have no significant meaning.
+    /// The order of lints in the `[lints]` is ignored, to have a lint override a group the
+    /// `priority` field needs to be used, otherwise the sort order is undefined.
+    ///
+    /// ### Known problems
+    /// Does not check lints inherited using `lints.workspace = true`
     ///
     /// ### Example
     /// ```toml
-    /// # The `Cargo.toml` with feature name redundancy
-    /// [features]
-    /// default = ["use-abc", "with-def", "ghi-support"]
-    /// use-abc = []  // redundant
-    /// with-def = []   // redundant
-    /// ghi-support = []   // redundant
+    /// # Passed as `--allow=clippy::similar_names --warn=clippy::pedantic`
+    /// # which results in `similar_names` being `warn`
+    /// [lints.clippy]
+    /// pedantic = "warn"
+    /// similar_names = "allow"
     /// ```
-    ///
     /// Use instead:
     /// ```toml
-    /// [features]
-    /// default = ["abc", "def", "ghi"]
-    /// abc = []
-    /// def = []
-    /// ghi = []
+    /// # Passed as `--warn=clippy::pedantic --allow=clippy::similar_names`
+    /// # which results in `similar_names` being `allow`
+    /// [lints.clippy]
+    /// pedantic = { level = "warn", priority = -1 }
+    /// similar_names = "allow"
     /// ```
+    #[clippy::version = "1.78.0"]
+    pub LINT_GROUPS_PRIORITY,
+    correctness,
+    "a lint group in `Cargo.toml` at the same priority as a lint"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks to see if multiple versions of a crate are being
+    /// used.
     ///
-    #[clippy::version = "1.57.0"]
-    pub REDUNDANT_FEATURE_NAMES,
+    /// ### Why is this bad?
+    /// This bloats the size of targets, and can lead to
+    /// confusing error messages when structs or traits are used interchangeably
+    /// between different versions of a crate.
+    ///
+    /// ### Known problems
+    /// Because this can be caused purely by the dependencies
+    /// themselves, it's not always possible to fix this issue.
+    /// In those cases, you can allow that specific crate using
+    /// the `allowed-duplicate-crates` configuration option.
+    ///
+    /// ### Example
+    /// ```toml
+    /// # This will pull in both winapi v0.3.x and v0.2.x, triggering a warning.
+    /// [dependencies]
+    /// ctrlc = "=3.1.0"
+    /// ansi_term = "=0.11.0"
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MULTIPLE_CRATE_VERSIONS,
     cargo,
-    "usage of a redundant feature name"
+    "multiple versions of the same crate being used"
 }
 
 declare_clippy_lint! {
@@ -120,31 +154,34 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks to see if multiple versions of a crate are being
-    /// used.
+    /// Checks for feature names with prefix `use-`, `with-` or suffix `-support`
     ///
     /// ### Why is this bad?
-    /// This bloats the size of targets, and can lead to
-    /// confusing error messages when structs or traits are used interchangeably
-    /// between different versions of a crate.
-    ///
-    /// ### Known problems
-    /// Because this can be caused purely by the dependencies
-    /// themselves, it's not always possible to fix this issue.
-    /// In those cases, you can allow that specific crate using
-    /// the `allowed-duplicate-crates` configuration option.
+    /// These prefixes and suffixes have no significant meaning.
     ///
     /// ### Example
     /// ```toml
-    /// # This will pull in both winapi v0.3.x and v0.2.x, triggering a warning.
-    /// [dependencies]
-    /// ctrlc = "=3.1.0"
-    /// ansi_term = "=0.11.0"
+    /// # The `Cargo.toml` with feature name redundancy
+    /// [features]
+    /// default = ["use-abc", "with-def", "ghi-support"]
+    /// use-abc = []  // redundant
+    /// with-def = []   // redundant
+    /// ghi-support = []   // redundant
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MULTIPLE_CRATE_VERSIONS,
+    ///
+    /// Use instead:
+    /// ```toml
+    /// [features]
+    /// default = ["abc", "def", "ghi"]
+    /// abc = []
+    /// def = []
+    /// ghi = []
+    /// ```
+    ///
+    #[clippy::version = "1.57.0"]
+    pub REDUNDANT_FEATURE_NAMES,
     cargo,
-    "multiple versions of the same crate being used"
+    "usage of a redundant feature name"
 }
 
 declare_clippy_lint! {
@@ -176,57 +213,20 @@ declare_clippy_lint! {
     "wildcard dependencies being used"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for lint groups with the same priority as lints in the `Cargo.toml`
-    /// [`[lints]` table](https://doc.rust-lang.org/cargo/reference/manifest.html#the-lints-section).
-    ///
-    /// This lint will be removed once [cargo#12918](https://github.com/rust-lang/cargo/issues/12918)
-    /// is resolved.
-    ///
-    /// ### Why is this bad?
-    /// The order of lints in the `[lints]` is ignored, to have a lint override a group the
-    /// `priority` field needs to be used, otherwise the sort order is undefined.
-    ///
-    /// ### Known problems
-    /// Does not check lints inherited using `lints.workspace = true`
-    ///
-    /// ### Example
-    /// ```toml
-    /// # Passed as `--allow=clippy::similar_names --warn=clippy::pedantic`
-    /// # which results in `similar_names` being `warn`
-    /// [lints.clippy]
-    /// pedantic = "warn"
-    /// similar_names = "allow"
-    /// ```
-    /// Use instead:
-    /// ```toml
-    /// # Passed as `--warn=clippy::pedantic --allow=clippy::similar_names`
-    /// # which results in `similar_names` being `allow`
-    /// [lints.clippy]
-    /// pedantic = { level = "warn", priority = -1 }
-    /// similar_names = "allow"
-    /// ```
-    #[clippy::version = "1.78.0"]
-    pub LINT_GROUPS_PRIORITY,
-    correctness,
-    "a lint group in `Cargo.toml` at the same priority as a lint"
-}
-
-pub struct Cargo {
-    allowed_duplicate_crates: FxHashSet<String>,
-    ignore_publish: bool,
-}
-
 impl_lint_pass!(Cargo => [
     CARGO_COMMON_METADATA,
-    REDUNDANT_FEATURE_NAMES,
-    NEGATIVE_FEATURE_NAMES,
+    LINT_GROUPS_PRIORITY,
     MULTIPLE_CRATE_VERSIONS,
+    NEGATIVE_FEATURE_NAMES,
+    REDUNDANT_FEATURE_NAMES,
     WILDCARD_DEPENDENCIES,
-    LINT_GROUPS_PRIORITY,
 ]);
 
+pub struct Cargo {
+    allowed_duplicate_crates: FxHashSet<String>,
+    ignore_publish: bool,
+}
+
 impl Cargo {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 3c9ebef73f0d..75761de4ae73 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -36,50 +36,231 @@ use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts from any numeric type to a float type where
-    /// the receiving type cannot store all values from the original type without
-    /// rounding errors. This possible rounding is to be expected, so this lint is
-    /// `Allow` by default.
+    /// Checks for the usage of `as *const _` or `as *mut _` conversion using inferred type.
     ///
-    /// Basically, this warns on casting any integer with 32 or more bits to `f32`
-    /// or any 64-bit integer to `f64`.
+    /// ### Why restrict this?
+    /// The conversion might include a dangerous cast that might go undetected due to the type being inferred.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn as_usize<T>(t: &T) -> usize {
+    ///     // BUG: `t` is already a reference, so we will here
+    ///     // return a dangling pointer to a temporary value instead
+    ///     &t as *const _ as usize
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn as_usize<T>(t: &T) -> usize {
+    ///     t as *const T as usize
+    /// }
+    /// ```
+    #[clippy::version = "1.85.0"]
+    pub AS_POINTER_UNDERSCORE,
+    restriction,
+    "detects `as *mut _` and `as *const _` conversion"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the result of a `&self`-taking `as_ptr` being cast to a mutable pointer.
     ///
     /// ### Why is this bad?
-    /// It's not bad at all. But in some applications it can be
-    /// helpful to know where precision loss can take place. This lint can help find
-    /// those places in the code.
+    /// Since `as_ptr` takes a `&self`, the pointer won't have write permissions unless interior
+    /// mutability is used, making it unlikely that having it as a mutable pointer is correct.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = u64::MAX;
-    /// x as f64;
+    /// let mut vec = Vec::<u8>::with_capacity(1);
+    /// let ptr = vec.as_ptr() as *mut u8;
+    /// unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub CAST_PRECISION_LOSS,
+    /// Use instead:
+    /// ```no_run
+    /// let mut vec = Vec::<u8>::with_capacity(1);
+    /// let ptr = vec.as_mut_ptr();
+    /// unsafe { ptr.write(4) };
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub AS_PTR_CAST_MUT,
+    nursery,
+    "casting the result of the `&self`-taking `as_ptr` to a mutable pointer"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of `as _` conversion using inferred type.
+    ///
+    /// ### Why restrict this?
+    /// The conversion might include lossy conversion or a dangerous cast that might go
+    /// undetected due to the type being inferred.
+    ///
+    /// The lint is allowed by default as using `_` is less wordy than always specifying the type.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo(n: usize) {}
+    /// let n: u16 = 256;
+    /// foo(n as _);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn foo(n: usize) {}
+    /// let n: u16 = 256;
+    /// foo(n as usize);
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub AS_UNDERSCORE,
+    restriction,
+    "detects `as _` conversion"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of `&expr as *const T` or
+    /// `&mut expr as *mut T`, and suggest using `&raw const` or
+    /// `&raw mut` instead.
+    ///
+    /// ### Why is this bad?
+    /// This would improve readability and avoid creating a reference
+    /// that points to an uninitialized value or unaligned place.
+    /// Read the `&raw` explanation in the Reference for more information.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let val = 1;
+    /// let p = &val as *const i32;
+    ///
+    /// let mut val_mut = 1;
+    /// let p_mut = &mut val_mut as *mut i32;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let val = 1;
+    /// let p = &raw const val;
+    ///
+    /// let mut val_mut = 1;
+    /// let p_mut = &raw mut val_mut;
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub BORROW_AS_PTR,
     pedantic,
-    "casts that cause loss of precision, e.g., `x as f32` where `x: u64`"
+    "borrowing just to cast to a raw pointer"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts from a signed to an unsigned numeric
-    /// type. In this case, negative values wrap around to large positive values,
-    /// which can be quite surprising in practice. However, since the cast works as
-    /// defined, this lint is `Allow` by default.
+    /// Checks for usage of the `abs()` method that cast the result to unsigned.
     ///
     /// ### Why is this bad?
-    /// Possibly surprising results. You can activate this lint
-    /// as a one-time check to see where numeric wrapping can arise.
+    /// The `unsigned_abs()` method avoids panic when called on the MIN value.
     ///
     /// ### Example
     /// ```no_run
-    /// let y: i8 = -1;
-    /// y as u64; // will return 18446744073709551615
+    /// let x: i32 = -42;
+    /// let y: u32 = x.abs() as u32;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x: i32 = -42;
+    /// let y: u32 = x.unsigned_abs();
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub CAST_ABS_TO_UNSIGNED,
+    suspicious,
+    "casting the result of `abs()` to an unsigned integer can panic"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts from an enum tuple constructor to an integer.
+    ///
+    /// ### Why is this bad?
+    /// The cast is easily confused with casting a c-like enum value to an integer.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// enum E { X(i32) };
+    /// let _ = E::X as usize;
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub CAST_ENUM_CONSTRUCTOR,
+    suspicious,
+    "casts from an enum tuple constructor to an integer"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts from an enum type to an integral type that will definitely truncate the
+    /// value.
+    ///
+    /// ### Why is this bad?
+    /// The resulting integral value will not match the value of the variant it came from.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// enum E { X = 256 };
+    /// let _ = E::X as u8;
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub CAST_ENUM_TRUNCATION,
+    suspicious,
+    "casts from an enum type to an integral type that will truncate the value"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts between numeric types that can be replaced by safe
+    /// conversion functions.
+    ///
+    /// ### Why is this bad?
+    /// Rust's `as` keyword will perform many kinds of conversions, including
+    /// silently lossy conversions. Conversion functions such as `i32::from`
+    /// will only perform lossless conversions. Using the conversion functions
+    /// prevents conversions from becoming silently lossy if the input types
+    /// ever change, and makes it clear for people reading the code that the
+    /// conversion is lossless.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn as_u64(x: u8) -> u64 {
+    ///     x as u64
+    /// }
+    /// ```
+    ///
+    /// Using `::from` would look like this:
+    ///
+    /// ```no_run
+    /// fn as_u64(x: u8) -> u64 {
+    ///     u64::from(x)
+    /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub CAST_SIGN_LOSS,
+    pub CAST_LOSSLESS,
     pedantic,
-    "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`"
+    "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for a known NaN float being cast to an integer
+    ///
+    /// ### Why is this bad?
+    /// NaNs are cast into zero, so one could simply use this and make the
+    /// code more readable. The lint could also hint at a programmer error.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let _ = (0.0_f32 / 0.0) as u64;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// let _ = 0_u64;
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub CAST_NAN_TO_INT,
+    suspicious,
+    "casting a known floating-point NaN into an integer"
 }
 
 declare_clippy_lint! {
@@ -159,71 +340,28 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts between numeric types that can be replaced by safe
-    /// conversion functions.
+    /// Checks for casts from any numeric type to a float type where
+    /// the receiving type cannot store all values from the original type without
+    /// rounding errors. This possible rounding is to be expected, so this lint is
+    /// `Allow` by default.
+    ///
+    /// Basically, this warns on casting any integer with 32 or more bits to `f32`
+    /// or any 64-bit integer to `f64`.
     ///
     /// ### Why is this bad?
-    /// Rust's `as` keyword will perform many kinds of conversions, including
-    /// silently lossy conversions. Conversion functions such as `i32::from`
-    /// will only perform lossless conversions. Using the conversion functions
-    /// prevents conversions from becoming silently lossy if the input types
-    /// ever change, and makes it clear for people reading the code that the
-    /// conversion is lossless.
+    /// It's not bad at all. But in some applications it can be
+    /// helpful to know where precision loss can take place. This lint can help find
+    /// those places in the code.
     ///
     /// ### Example
     /// ```no_run
-    /// fn as_u64(x: u8) -> u64 {
-    ///     x as u64
-    /// }
-    /// ```
-    ///
-    /// Using `::from` would look like this:
-    ///
-    /// ```no_run
-    /// fn as_u64(x: u8) -> u64 {
-    ///     u64::from(x)
-    /// }
+    /// let x = u64::MAX;
+    /// x as f64;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub CAST_LOSSLESS,
+    pub CAST_PRECISION_LOSS,
     pedantic,
-    "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for casts to the same type, casts of int literals to integer
-    /// types, casts of float literals to float types, and casts between raw
-    /// pointers that don't change type or constness.
-    ///
-    /// ### Why is this bad?
-    /// It's just unnecessary.
-    ///
-    /// ### Known problems
-    /// When the expression on the left is a function call, the lint considers
-    /// the return type to be a type alias if it's aliased through a `use`
-    /// statement (like `use std::io::Result as IoResult`). It will not lint
-    /// such cases.
-    ///
-    /// This check will only work on primitive types without any intermediate
-    /// references: raw pointers and trait objects may or may not work.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = 2i32 as i32;
-    /// let _ = 0.5 as f32;
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```no_run
-    /// let _ = 2_i32;
-    /// let _ = 0.5_f32;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub UNNECESSARY_CAST,
-    complexity,
-    "cast to the same type, e.g., `x as i32` where `x: i32`"
+    "casts that cause loss of precision, e.g., `x as f32` where `x: u64`"
 }
 
 declare_clippy_lint! {
@@ -256,107 +394,96 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts of function pointers to something other than `usize`.
+    /// Checks for casts from a signed to an unsigned numeric
+    /// type. In this case, negative values wrap around to large positive values,
+    /// which can be quite surprising in practice. However, since the cast works as
+    /// defined, this lint is `Allow` by default.
     ///
     /// ### Why is this bad?
-    /// Casting a function pointer to anything other than `usize`/`isize` is
-    /// not portable across architectures. If the target type is too small the
-    /// address would be truncated, and target types larger than `usize` are
-    /// unnecessary.
-    ///
-    /// Casting to `isize` also doesn't make sense, since addresses are never
-    /// signed.
+    /// Possibly surprising results. You can activate this lint
+    /// as a one-time check to see where numeric wrapping can arise.
     ///
     /// ### Example
     /// ```no_run
-    /// fn fun() -> i32 { 1 }
-    /// let _ = fun as i64;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # fn fun() -> i32 { 1 }
-    /// let _ = fun as usize;
+    /// let y: i8 = -1;
+    /// y as u64; // will return 18446744073709551615
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub FN_TO_NUMERIC_CAST,
-    style,
-    "casting a function pointer to a numeric type other than `usize`"
+    pub CAST_SIGN_LOSS,
+    pedantic,
+    "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts of a function pointer to a numeric type not wide enough to
-    /// store an address.
+    /// Checks for `as` casts between raw pointers to slices with differently sized elements.
     ///
     /// ### Why is this bad?
-    /// Such a cast discards some bits of the function's address. If this is intended, it would be more
-    /// clearly expressed by casting to `usize` first, then casting the `usize` to the intended type (with
-    /// a comment) to perform the truncation.
+    /// The produced raw pointer to a slice does not update its length metadata. The produced
+    /// pointer will point to a different number of bytes than the original pointer because the
+    /// length metadata of a raw slice pointer is in elements rather than bytes.
+    /// Producing a slice reference from the raw pointer will either create a slice with
+    /// less data (which can be surprising) or create a slice with more data and cause Undefined Behavior.
     ///
     /// ### Example
+    /// // Missing data
     /// ```no_run
-    /// fn fn1() -> i16 {
-    ///     1
-    /// };
-    /// let _ = fn1 as i32;
+    /// let a = [1_i32, 2, 3, 4];
+    /// let p = &a as *const [i32] as *const [u8];
+    /// unsafe {
+    ///     println!("{:?}", &*p);
+    /// }
     /// ```
-    ///
-    /// Use instead:
+    /// // Undefined Behavior (note: also potential alignment issues)
     /// ```no_run
-    /// // Cast to usize first, then comment with the reason for the truncation
-    /// fn fn1() -> i16 {
-    ///     1
-    /// };
-    /// let fn_ptr = fn1 as usize;
-    /// let fn_ptr_truncated = fn_ptr as i32;
+    /// let a = [1_u8, 2, 3, 4];
+    /// let p = &a as *const [u8] as *const [u32];
+    /// unsafe {
+    ///     println!("{:?}", &*p);
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-    style,
-    "casting a function pointer to a numeric type not wide enough to store the address"
+    /// Instead use `ptr::slice_from_raw_parts` to construct a slice from a data pointer and the correct length
+    /// ```no_run
+    /// let a = [1_i32, 2, 3, 4];
+    /// let old_ptr = &a as *const [i32];
+    /// // The data pointer is cast to a pointer to the target `u8` not `[u8]`
+    /// // The length comes from the known length of 4 i32s times the 4 bytes per i32
+    /// let new_ptr = core::ptr::slice_from_raw_parts(old_ptr as *const u8, 16);
+    /// unsafe {
+    ///     println!("{:?}", &*new_ptr);
+    /// }
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub CAST_SLICE_DIFFERENT_SIZES,
+    correctness,
+    "casting using `as` between raw pointers to slices of types with different sizes"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts of a function pointer to any integer type.
+    /// Checks for a raw slice being cast to a slice pointer
     ///
-    /// ### Why restrict this?
-    /// Casting a function pointer to an integer can have surprising results and can occur
-    /// accidentally if parentheses are omitted from a function call. If you aren't doing anything
-    /// low-level with function pointers then you can opt out of casting functions to integers in
-    /// order to avoid mistakes. Alternatively, you can use this lint to audit all uses of function
-    /// pointer casts in your code.
+    /// ### Why is this bad?
+    /// This can result in multiple `&mut` references to the same location when only a pointer is
+    /// required.
+    /// `ptr::slice_from_raw_parts` is a safe alternative that doesn't require
+    /// the same [safety requirements] to be upheld.
     ///
     /// ### Example
-    /// ```no_run
-    /// // fn1 is cast as `usize`
-    /// fn fn1() -> u16 {
-    ///     1
-    /// };
-    /// let _ = fn1 as usize;
+    /// ```rust,ignore
+    /// let _: *const [u8] = std::slice::from_raw_parts(ptr, len) as *const _;
+    /// let _: *mut [u8] = std::slice::from_raw_parts_mut(ptr, len) as *mut _;
     /// ```
-    ///
     /// Use instead:
-    /// ```no_run
-    /// // maybe you intended to call the function?
-    /// fn fn2() -> u16 {
-    ///     1
-    /// };
-    /// let _ = fn2() as usize;
-    ///
-    /// // or
-    ///
-    /// // maybe you intended to cast it to a function type?
-    /// fn fn3() -> u16 {
-    ///     1
-    /// }
-    /// let _ = fn3 as fn() -> u16;
+    /// ```rust,ignore
+    /// let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, len);
+    /// let _: *mut [u8] = std::ptr::slice_from_raw_parts_mut(ptr, len);
     /// ```
-    #[clippy::version = "1.58.0"]
-    pub FN_TO_NUMERIC_CAST_ANY,
-    restriction,
-    "casting a function pointer to any integer type"
+    /// [safety requirements]: https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html#safety
+    #[clippy::version = "1.65.0"]
+    pub CAST_SLICE_FROM_RAW_PARTS,
+    suspicious,
+    "casting a slice created from a pointer and length to a slice pointer"
 }
 
 declare_clippy_lint! {
@@ -389,332 +516,251 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `as` casts between raw pointers that don't change their
-    /// constness, namely `*const T` to `*const U` and `*mut T` to `*mut U`.
+    /// Checks for casts of a primitive method pointer like `max`/`min` to any integer type.
     ///
-    /// ### Why is this bad?
-    /// Though `as` casts between raw pointers are not terrible,
-    /// `pointer::cast` is safer because it cannot accidentally change the
-    /// pointer's mutability, nor cast the pointer to other types like `usize`.
+    /// ### Why restrict this?
+    /// Casting a function pointer to an integer can have surprising results and can occur
+    /// accidentally if parentheses are omitted from a function call. If you aren't doing anything
+    /// low-level with function pointers then you can opt out of casting functions to integers in
+    /// order to avoid mistakes. Alternatively, you can use this lint to audit all uses of function
+    /// pointer casts in your code.
     ///
     /// ### Example
     /// ```no_run
-    /// let ptr: *const u32 = &42_u32;
-    /// let mut_ptr: *mut u32 = &mut 42_u32;
-    /// let _ = ptr as *const i32;
-    /// let _ = mut_ptr as *mut i32;
+    /// let _ = u16::max as usize;
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let ptr: *const u32 = &42_u32;
-    /// let mut_ptr: *mut u32 = &mut 42_u32;
-    /// let _ = ptr.cast::<i32>();
-    /// let _ = mut_ptr.cast::<i32>();
+    /// let _ = u16::MAX as usize;
     /// ```
-    #[clippy::version = "1.51.0"]
-    pub PTR_AS_PTR,
-    pedantic,
-    "casting using `as` between raw pointers that doesn't change their constness, where `pointer::cast` could take the place of `as`"
+    #[clippy::version = "1.89.0"]
+    pub CONFUSING_METHOD_TO_NUMERIC_CAST,
+    suspicious,
+    "casting a primitive method pointer to any integer type"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `as` casts between raw pointers that change their constness, namely `*const T` to
-    /// `*mut T` and `*mut T` to `*const T`.
+    /// Checks for casts of function pointers to something other than `usize`.
     ///
     /// ### Why is this bad?
-    /// Though `as` casts between raw pointers are not terrible, `pointer::cast_mut` and
-    /// `pointer::cast_const` are safer because they cannot accidentally cast the pointer to another
-    /// type. Or, when null pointers are involved, `null()` and `null_mut()` can be used directly.
+    /// Casting a function pointer to anything other than `usize`/`isize` is
+    /// not portable across architectures. If the target type is too small the
+    /// address would be truncated, and target types larger than `usize` are
+    /// unnecessary.
+    ///
+    /// Casting to `isize` also doesn't make sense, since addresses are never
+    /// signed.
     ///
     /// ### Example
     /// ```no_run
-    /// let ptr: *const u32 = &42_u32;
-    /// let mut_ptr = ptr as *mut u32;
-    /// let ptr = mut_ptr as *const u32;
-    /// let ptr1 = std::ptr::null::<u32>() as *mut u32;
-    /// let ptr2 = std::ptr::null_mut::<u32>() as *const u32;
-    /// let ptr3 = std::ptr::null::<u32>().cast_mut();
-    /// let ptr4 = std::ptr::null_mut::<u32>().cast_const();
+    /// fn fun() -> i32 { 1 }
+    /// let _ = fun as i64;
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let ptr: *const u32 = &42_u32;
-    /// let mut_ptr = ptr.cast_mut();
-    /// let ptr = mut_ptr.cast_const();
-    /// let ptr1 = std::ptr::null_mut::<u32>();
-    /// let ptr2 = std::ptr::null::<u32>();
-    /// let ptr3 = std::ptr::null_mut::<u32>();
-    /// let ptr4 = std::ptr::null::<u32>();
+    /// # fn fun() -> i32 { 1 }
+    /// let _ = fun as usize;
     /// ```
-    #[clippy::version = "1.72.0"]
-    pub PTR_CAST_CONSTNESS,
-    pedantic,
-    "casting using `as` on raw pointers to change constness when specialized methods apply"
+    #[clippy::version = "pre 1.29.0"]
+    pub FN_TO_NUMERIC_CAST,
+    style,
+    "casting a function pointer to a numeric type other than `usize`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts from an enum type to an integral type that will definitely truncate the
-    /// value.
-    ///
-    /// ### Why is this bad?
-    /// The resulting integral value will not match the value of the variant it came from.
+    /// Checks for casts of a function pointer to any integer type.
     ///
-    /// ### Example
-    /// ```no_run
-    /// enum E { X = 256 };
-    /// let _ = E::X as u8;
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub CAST_ENUM_TRUNCATION,
-    suspicious,
-    "casts from an enum type to an integral type that will truncate the value"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `as` casts between raw pointers to slices with differently sized elements.
-    ///
-    /// ### Why is this bad?
-    /// The produced raw pointer to a slice does not update its length metadata. The produced
-    /// pointer will point to a different number of bytes than the original pointer because the
-    /// length metadata of a raw slice pointer is in elements rather than bytes.
-    /// Producing a slice reference from the raw pointer will either create a slice with
-    /// less data (which can be surprising) or create a slice with more data and cause Undefined Behavior.
-    ///
-    /// ### Example
-    /// // Missing data
-    /// ```no_run
-    /// let a = [1_i32, 2, 3, 4];
-    /// let p = &a as *const [i32] as *const [u8];
-    /// unsafe {
-    ///     println!("{:?}", &*p);
-    /// }
-    /// ```
-    /// // Undefined Behavior (note: also potential alignment issues)
-    /// ```no_run
-    /// let a = [1_u8, 2, 3, 4];
-    /// let p = &a as *const [u8] as *const [u32];
-    /// unsafe {
-    ///     println!("{:?}", &*p);
-    /// }
-    /// ```
-    /// Instead use `ptr::slice_from_raw_parts` to construct a slice from a data pointer and the correct length
-    /// ```no_run
-    /// let a = [1_i32, 2, 3, 4];
-    /// let old_ptr = &a as *const [i32];
-    /// // The data pointer is cast to a pointer to the target `u8` not `[u8]`
-    /// // The length comes from the known length of 4 i32s times the 4 bytes per i32
-    /// let new_ptr = core::ptr::slice_from_raw_parts(old_ptr as *const u8, 16);
-    /// unsafe {
-    ///     println!("{:?}", &*new_ptr);
-    /// }
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub CAST_SLICE_DIFFERENT_SIZES,
-    correctness,
-    "casting using `as` between raw pointers to slices of types with different sizes"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for casts from an enum tuple constructor to an integer.
-    ///
-    /// ### Why is this bad?
-    /// The cast is easily confused with casting a c-like enum value to an integer.
+    /// ### Why restrict this?
+    /// Casting a function pointer to an integer can have surprising results and can occur
+    /// accidentally if parentheses are omitted from a function call. If you aren't doing anything
+    /// low-level with function pointers then you can opt out of casting functions to integers in
+    /// order to avoid mistakes. Alternatively, you can use this lint to audit all uses of function
+    /// pointer casts in your code.
     ///
     /// ### Example
     /// ```no_run
-    /// enum E { X(i32) };
-    /// let _ = E::X as usize;
+    /// // fn1 is cast as `usize`
+    /// fn fn1() -> u16 {
+    ///     1
+    /// };
+    /// let _ = fn1 as usize;
     /// ```
-    #[clippy::version = "1.61.0"]
-    pub CAST_ENUM_CONSTRUCTOR,
-    suspicious,
-    "casts from an enum tuple constructor to an integer"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of the `abs()` method that cast the result to unsigned.
     ///
-    /// ### Why is this bad?
-    /// The `unsigned_abs()` method avoids panic when called on the MIN value.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: i32 = -42;
-    /// let y: u32 = x.abs() as u32;
-    /// ```
     /// Use instead:
     /// ```no_run
-    /// let x: i32 = -42;
-    /// let y: u32 = x.unsigned_abs();
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub CAST_ABS_TO_UNSIGNED,
-    suspicious,
-    "casting the result of `abs()` to an unsigned integer can panic"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the usage of `as _` conversion using inferred type.
-    ///
-    /// ### Why restrict this?
-    /// The conversion might include lossy conversion or a dangerous cast that might go
-    /// undetected due to the type being inferred.
+    /// // maybe you intended to call the function?
+    /// fn fn2() -> u16 {
+    ///     1
+    /// };
+    /// let _ = fn2() as usize;
     ///
-    /// The lint is allowed by default as using `_` is less wordy than always specifying the type.
+    /// // or
     ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo(n: usize) {}
-    /// let n: u16 = 256;
-    /// foo(n as _);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn foo(n: usize) {}
-    /// let n: u16 = 256;
-    /// foo(n as usize);
+    /// // maybe you intended to cast it to a function type?
+    /// fn fn3() -> u16 {
+    ///     1
+    /// }
+    /// let _ = fn3 as fn() -> u16;
     /// ```
-    #[clippy::version = "1.63.0"]
-    pub AS_UNDERSCORE,
+    #[clippy::version = "1.58.0"]
+    pub FN_TO_NUMERIC_CAST_ANY,
     restriction,
-    "detects `as _` conversion"
+    "casting a function pointer to any integer type"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of `&expr as *const T` or
-    /// `&mut expr as *mut T`, and suggest using `&raw const` or
-    /// `&raw mut` instead.
+    /// Checks for casts of a function pointer to a numeric type not wide enough to
+    /// store an address.
     ///
     /// ### Why is this bad?
-    /// This would improve readability and avoid creating a reference
-    /// that points to an uninitialized value or unaligned place.
-    /// Read the `&raw` explanation in the Reference for more information.
+    /// Such a cast discards some bits of the function's address. If this is intended, it would be more
+    /// clearly expressed by casting to `usize` first, then casting the `usize` to the intended type (with
+    /// a comment) to perform the truncation.
     ///
     /// ### Example
     /// ```no_run
-    /// let val = 1;
-    /// let p = &val as *const i32;
-    ///
-    /// let mut val_mut = 1;
-    /// let p_mut = &mut val_mut as *mut i32;
+    /// fn fn1() -> i16 {
+    ///     1
+    /// };
+    /// let _ = fn1 as i32;
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let val = 1;
-    /// let p = &raw const val;
-    ///
-    /// let mut val_mut = 1;
-    /// let p_mut = &raw mut val_mut;
+    /// // Cast to usize first, then comment with the reason for the truncation
+    /// fn fn1() -> i16 {
+    ///     1
+    /// };
+    /// let fn_ptr = fn1 as usize;
+    /// let fn_ptr_truncated = fn_ptr as i32;
     /// ```
-    #[clippy::version = "1.60.0"]
-    pub BORROW_AS_PTR,
-    pedantic,
-    "borrowing just to cast to a raw pointer"
+    #[clippy::version = "pre 1.29.0"]
+    pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+    style,
+    "casting a function pointer to a numeric type not wide enough to store the address"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for a raw slice being cast to a slice pointer
+    /// Checks for casts of small constant literals or `mem::align_of` results to raw pointers.
     ///
     /// ### Why is this bad?
-    /// This can result in multiple `&mut` references to the same location when only a pointer is
-    /// required.
-    /// `ptr::slice_from_raw_parts` is a safe alternative that doesn't require
-    /// the same [safety requirements] to be upheld.
+    /// This creates a dangling pointer and is better expressed as
+    /// {`std`, `core`}`::ptr::`{`dangling`, `dangling_mut`}.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// let _: *const [u8] = std::slice::from_raw_parts(ptr, len) as *const _;
-    /// let _: *mut [u8] = std::slice::from_raw_parts_mut(ptr, len) as *mut _;
+    /// ```no_run
+    /// let ptr = 4 as *const u32;
+    /// let aligned = std::mem::align_of::<u32>() as *const u32;
+    /// let mut_ptr: *mut i64 = 8 as *mut _;
     /// ```
     /// Use instead:
-    /// ```rust,ignore
-    /// let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, len);
-    /// let _: *mut [u8] = std::ptr::slice_from_raw_parts_mut(ptr, len);
+    /// ```no_run
+    /// let ptr = std::ptr::dangling::<u32>();
+    /// let aligned = std::ptr::dangling::<u32>();
+    /// let mut_ptr: *mut i64 = std::ptr::dangling_mut();
     /// ```
-    /// [safety requirements]: https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html#safety
-    #[clippy::version = "1.65.0"]
-    pub CAST_SLICE_FROM_RAW_PARTS,
-    suspicious,
-    "casting a slice created from a pointer and length to a slice pointer"
+    #[clippy::version = "1.88.0"]
+    pub MANUAL_DANGLING_PTR,
+    style,
+    "casting small constant literals to pointers to create dangling pointers"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the result of a `&self`-taking `as_ptr` being cast to a mutable pointer.
+    /// Checks for bindings (constants, statics, or let bindings) that are defined
+    /// with one numeric type but are consistently cast to a different type in all usages.
     ///
     /// ### Why is this bad?
-    /// Since `as_ptr` takes a `&self`, the pointer won't have write permissions unless interior
-    /// mutability is used, making it unlikely that having it as a mutable pointer is correct.
+    /// If a binding is always cast to a different type when used, it would be clearer
+    /// and more efficient to define it with the target type from the start.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut vec = Vec::<u8>::with_capacity(1);
-    /// let ptr = vec.as_ptr() as *mut u8;
-    /// unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
+    /// const SIZE: u16 = 15;
+    /// let arr: [u8; SIZE as usize] = [0; SIZE as usize];
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let mut vec = Vec::<u8>::with_capacity(1);
-    /// let ptr = vec.as_mut_ptr();
-    /// unsafe { ptr.write(4) };
+    /// const SIZE: usize = 15;
+    /// let arr: [u8; SIZE] = [0; SIZE];
     /// ```
-    #[clippy::version = "1.66.0"]
-    pub AS_PTR_CAST_MUT,
+    #[clippy::version = "1.93.0"]
+    pub NEEDLESS_TYPE_CAST,
     nursery,
-    "casting the result of the `&self`-taking `as_ptr` to a mutable pointer"
+    "binding defined with one type but always cast to another"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for a known NaN float being cast to an integer
+    /// Checks for `as` casts between raw pointers that don't change their
+    /// constness, namely `*const T` to `*const U` and `*mut T` to `*mut U`.
     ///
     /// ### Why is this bad?
-    /// NaNs are cast into zero, so one could simply use this and make the
-    /// code more readable. The lint could also hint at a programmer error.
+    /// Though `as` casts between raw pointers are not terrible,
+    /// `pointer::cast` is safer because it cannot accidentally change the
+    /// pointer's mutability, nor cast the pointer to other types like `usize`.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// let _ = (0.0_f32 / 0.0) as u64;
+    /// ```no_run
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr: *mut u32 = &mut 42_u32;
+    /// let _ = ptr as *const i32;
+    /// let _ = mut_ptr as *mut i32;
     /// ```
     /// Use instead:
-    /// ```rust,ignore
-    /// let _ = 0_u64;
+    /// ```no_run
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr: *mut u32 = &mut 42_u32;
+    /// let _ = ptr.cast::<i32>();
+    /// let _ = mut_ptr.cast::<i32>();
     /// ```
-    #[clippy::version = "1.66.0"]
-    pub CAST_NAN_TO_INT,
-    suspicious,
-    "casting a known floating-point NaN into an integer"
+    #[clippy::version = "1.51.0"]
+    pub PTR_AS_PTR,
+    pedantic,
+    "casting using `as` between raw pointers that doesn't change their constness, where `pointer::cast` could take the place of `as`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Catch casts from `0` to some pointer type
+    /// Checks for `as` casts between raw pointers that change their constness, namely `*const T` to
+    /// `*mut T` and `*mut T` to `*const T`.
     ///
     /// ### Why is this bad?
-    /// This generally means `null` and is better expressed as
-    /// {`std`, `core`}`::ptr::`{`null`, `null_mut`}.
+    /// Though `as` casts between raw pointers are not terrible, `pointer::cast_mut` and
+    /// `pointer::cast_const` are safer because they cannot accidentally cast the pointer to another
+    /// type. Or, when null pointers are involved, `null()` and `null_mut()` can be used directly.
     ///
     /// ### Example
     /// ```no_run
-    /// let a = 0 as *const u32;
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr = ptr as *mut u32;
+    /// let ptr = mut_ptr as *const u32;
+    /// let ptr1 = std::ptr::null::<u32>() as *mut u32;
+    /// let ptr2 = std::ptr::null_mut::<u32>() as *const u32;
+    /// let ptr3 = std::ptr::null::<u32>().cast_mut();
+    /// let ptr4 = std::ptr::null_mut::<u32>().cast_const();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// let a = std::ptr::null::<u32>();
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr = ptr.cast_mut();
+    /// let ptr = mut_ptr.cast_const();
+    /// let ptr1 = std::ptr::null_mut::<u32>();
+    /// let ptr2 = std::ptr::null::<u32>();
+    /// let ptr3 = std::ptr::null_mut::<u32>();
+    /// let ptr4 = std::ptr::null::<u32>();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ZERO_PTR,
-    style,
-    "using `0 as *{const, mut} T`"
+    #[clippy::version = "1.72.0"]
+    pub PTR_CAST_CONSTNESS,
+    pedantic,
+    "casting using `as` on raw pointers to change constness when specialized methods apply"
 }
 
 declare_clippy_lint! {
@@ -743,150 +789,104 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of `as *const _` or `as *mut _` conversion using inferred type.
-    ///
-    /// ### Why restrict this?
-    /// The conversion might include a dangerous cast that might go undetected due to the type being inferred.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn as_usize<T>(t: &T) -> usize {
-    ///     // BUG: `t` is already a reference, so we will here
-    ///     // return a dangling pointer to a temporary value instead
-    ///     &t as *const _ as usize
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn as_usize<T>(t: &T) -> usize {
-    ///     t as *const T as usize
-    /// }
-    /// ```
-    #[clippy::version = "1.85.0"]
-    pub AS_POINTER_UNDERSCORE,
-    restriction,
-    "detects `as *mut _` and `as *const _` conversion"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for casts of small constant literals or `mem::align_of` results to raw pointers.
+    /// Checks for casts to the same type, casts of int literals to integer
+    /// types, casts of float literals to float types, and casts between raw
+    /// pointers that don't change type or constness.
     ///
     /// ### Why is this bad?
-    /// This creates a dangling pointer and is better expressed as
-    /// {`std`, `core`}`::ptr::`{`dangling`, `dangling_mut`}.
+    /// It's just unnecessary.
     ///
-    /// ### Example
-    /// ```no_run
-    /// let ptr = 4 as *const u32;
-    /// let aligned = std::mem::align_of::<u32>() as *const u32;
-    /// let mut_ptr: *mut i64 = 8 as *mut _;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let ptr = std::ptr::dangling::<u32>();
-    /// let aligned = std::ptr::dangling::<u32>();
-    /// let mut_ptr: *mut i64 = std::ptr::dangling_mut();
-    /// ```
-    #[clippy::version = "1.88.0"]
-    pub MANUAL_DANGLING_PTR,
-    style,
-    "casting small constant literals to pointers to create dangling pointers"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for casts of a primitive method pointer like `max`/`min` to any integer type.
+    /// ### Known problems
+    /// When the expression on the left is a function call, the lint considers
+    /// the return type to be a type alias if it's aliased through a `use`
+    /// statement (like `use std::io::Result as IoResult`). It will not lint
+    /// such cases.
     ///
-    /// ### Why restrict this?
-    /// Casting a function pointer to an integer can have surprising results and can occur
-    /// accidentally if parentheses are omitted from a function call. If you aren't doing anything
-    /// low-level with function pointers then you can opt out of casting functions to integers in
-    /// order to avoid mistakes. Alternatively, you can use this lint to audit all uses of function
-    /// pointer casts in your code.
+    /// This check will only work on primitive types without any intermediate
+    /// references: raw pointers and trait objects may or may not work.
     ///
     /// ### Example
     /// ```no_run
-    /// let _ = u16::max as usize;
+    /// let _ = 2i32 as i32;
+    /// let _ = 0.5 as f32;
     /// ```
     ///
-    /// Use instead:
+    /// Better:
+    ///
     /// ```no_run
-    /// let _ = u16::MAX as usize;
+    /// let _ = 2_i32;
+    /// let _ = 0.5_f32;
     /// ```
-    #[clippy::version = "1.89.0"]
-    pub CONFUSING_METHOD_TO_NUMERIC_CAST,
-    suspicious,
-    "casting a primitive method pointer to any integer type"
+    #[clippy::version = "pre 1.29.0"]
+    pub UNNECESSARY_CAST,
+    complexity,
+    "cast to the same type, e.g., `x as i32` where `x: i32`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for bindings (constants, statics, or let bindings) that are defined
-    /// with one numeric type but are consistently cast to a different type in all usages.
+    /// Catch casts from `0` to some pointer type
     ///
     /// ### Why is this bad?
-    /// If a binding is always cast to a different type when used, it would be clearer
-    /// and more efficient to define it with the target type from the start.
+    /// This generally means `null` and is better expressed as
+    /// {`std`, `core`}`::ptr::`{`null`, `null_mut`}.
     ///
     /// ### Example
     /// ```no_run
-    /// const SIZE: u16 = 15;
-    /// let arr: [u8; SIZE as usize] = [0; SIZE as usize];
+    /// let a = 0 as *const u32;
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// const SIZE: usize = 15;
-    /// let arr: [u8; SIZE] = [0; SIZE];
+    /// let a = std::ptr::null::<u32>();
     /// ```
-    #[clippy::version = "1.93.0"]
-    pub NEEDLESS_TYPE_CAST,
-    nursery,
-    "binding defined with one type but always cast to another"
-}
-
-pub struct Casts {
-    msrv: Msrv,
-}
-
-impl Casts {
-    pub fn new(conf: &'static Conf) -> Self {
-        Self { msrv: conf.msrv }
-    }
+    #[clippy::version = "pre 1.29.0"]
+    pub ZERO_PTR,
+    style,
+    "using `0 as *{const, mut} T`"
 }
 
 impl_lint_pass!(Casts => [
-    CAST_PRECISION_LOSS,
-    CAST_SIGN_LOSS,
+    AS_POINTER_UNDERSCORE,
+    AS_PTR_CAST_MUT,
+    AS_UNDERSCORE,
+    BORROW_AS_PTR,
+    CAST_ABS_TO_UNSIGNED,
+    CAST_ENUM_CONSTRUCTOR,
+    CAST_ENUM_TRUNCATION,
+    CAST_LOSSLESS,
+    CAST_NAN_TO_INT,
     CAST_POSSIBLE_TRUNCATION,
     CAST_POSSIBLE_WRAP,
-    CAST_LOSSLESS,
+    CAST_PRECISION_LOSS,
     CAST_PTR_ALIGNMENT,
+    CAST_SIGN_LOSS,
     CAST_SLICE_DIFFERENT_SIZES,
-    UNNECESSARY_CAST,
-    FN_TO_NUMERIC_CAST_ANY,
+    CAST_SLICE_FROM_RAW_PARTS,
+    CHAR_LIT_AS_U8,
+    CONFUSING_METHOD_TO_NUMERIC_CAST,
     FN_TO_NUMERIC_CAST,
+    FN_TO_NUMERIC_CAST_ANY,
     FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-    CHAR_LIT_AS_U8,
+    MANUAL_DANGLING_PTR,
+    NEEDLESS_TYPE_CAST,
     PTR_AS_PTR,
     PTR_CAST_CONSTNESS,
-    CAST_ENUM_TRUNCATION,
-    CAST_ENUM_CONSTRUCTOR,
-    CAST_ABS_TO_UNSIGNED,
-    AS_UNDERSCORE,
-    BORROW_AS_PTR,
-    CAST_SLICE_FROM_RAW_PARTS,
-    AS_PTR_CAST_MUT,
-    CAST_NAN_TO_INT,
-    ZERO_PTR,
     REF_AS_PTR,
-    AS_POINTER_UNDERSCORE,
-    MANUAL_DANGLING_PTR,
-    CONFUSING_METHOD_TO_NUMERIC_CAST,
-    NEEDLESS_TYPE_CAST,
+    UNNECESSARY_CAST,
+    ZERO_PTR,
 ]);
 
+pub struct Casts {
+    msrv: Msrv,
+}
+
+impl Casts {
+    pub fn new(conf: &'static Conf) -> Self {
+        Self { msrv: conf.msrv }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for Casts {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if expr.span.in_external_macro(cx.sess().source_map()) {
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 8303897d1294..5e9009c67197 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -34,6 +34,8 @@ declare_clippy_lint! {
     "`try_from` could replace manual bounds checking when casting"
 }
 
+impl_lint_pass!(CheckedConversions => [CHECKED_CONVERSIONS]);
+
 pub struct CheckedConversions {
     msrv: Msrv,
 }
@@ -44,8 +46,6 @@ impl CheckedConversions {
     }
 }
 
-impl_lint_pass!(CheckedConversions => [CHECKED_CONVERSIONS]);
-
 impl LateLintPass<'_> for CheckedConversions {
     fn check_expr(&mut self, cx: &LateContext<'_>, item: &Expr<'_>) {
         if let ExprKind::Binary(op, lhs, rhs) = item.kind
diff --git a/clippy_lints/src/cloned_ref_to_slice_refs.rs b/clippy_lints/src/cloned_ref_to_slice_refs.rs
index 35b799aefb04..c5eabe4c2b88 100644
--- a/clippy_lints/src/cloned_ref_to_slice_refs.rs
+++ b/clippy_lints/src/cloned_ref_to_slice_refs.rs
@@ -44,6 +44,8 @@ declare_clippy_lint! {
     "cloning a reference for slice references"
 }
 
+impl_lint_pass!(ClonedRefToSliceRefs<'_> => [CLONED_REF_TO_SLICE_REFS]);
+
 pub struct ClonedRefToSliceRefs<'a> {
     msrv: &'a Msrv,
 }
@@ -53,8 +55,6 @@ impl<'a> ClonedRefToSliceRefs<'a> {
     }
 }
 
-impl_lint_pass!(ClonedRefToSliceRefs<'_> => [CLONED_REF_TO_SLICE_REFS]);
-
 impl<'tcx> LateLintPass<'tcx> for ClonedRefToSliceRefs<'_> {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         if self.msrv.meets(cx, {
diff --git a/clippy_lints/src/coerce_container_to_any.rs b/clippy_lints/src/coerce_container_to_any.rs
index 2e3acb7748e2..1a7e20b98271 100644
--- a/clippy_lints/src/coerce_container_to_any.rs
+++ b/clippy_lints/src/coerce_container_to_any.rs
@@ -46,6 +46,7 @@ declare_clippy_lint! {
     nursery,
     "coercing to `&dyn Any` when dereferencing could produce a `dyn Any` without coercion is usually not intended"
 }
+
 declare_lint_pass!(CoerceContainerToAny => [COERCE_CONTAINER_TO_ANY]);
 
 impl<'tcx> LateLintPass<'tcx> for CoerceContainerToAny {
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 950ac863d755..eaad18d25436 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -40,6 +40,8 @@ declare_clippy_lint! {
     @eval_always = true
 }
 
+impl_lint_pass!(CognitiveComplexity => [COGNITIVE_COMPLEXITY]);
+
 pub struct CognitiveComplexity {
     limit: LimitStack,
 }
@@ -52,8 +54,6 @@ impl CognitiveComplexity {
     }
 }
 
-impl_lint_pass!(CognitiveComplexity => [COGNITIVE_COMPLEXITY]);
-
 impl CognitiveComplexity {
     fn check<'tcx>(
         &self,
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 17e11b8b281d..a76027caebc8 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -12,38 +12,6 @@ use rustc_session::impl_lint_pass;
 use rustc_span::source_map::SourceMap;
 use rustc_span::{BytePos, Span, Symbol};
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for nested `if` statements which can be collapsed
-    /// by `&&`-combining their conditions.
-    ///
-    /// ### Why is this bad?
-    /// Each `if`-statement adds one level of nesting, which
-    /// makes code look more complex than it really is.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let (x, y) = (true, true);
-    /// if x {
-    ///     if y {
-    ///         // …
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let (x, y) = (true, true);
-    /// if x && y {
-    ///     // …
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub COLLAPSIBLE_IF,
-    style,
-    "nested `if`s that can be collapsed (e.g., `if x { if y { ... } }`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for collapsible `else { if ... }` expressions
@@ -80,6 +48,40 @@ declare_clippy_lint! {
     "nested `else`-`if` expressions that can be collapsed (e.g., `else { if x { ... } }`)"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for nested `if` statements which can be collapsed
+    /// by `&&`-combining their conditions.
+    ///
+    /// ### Why is this bad?
+    /// Each `if`-statement adds one level of nesting, which
+    /// makes code look more complex than it really is.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let (x, y) = (true, true);
+    /// if x {
+    ///     if y {
+    ///         // …
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let (x, y) = (true, true);
+    /// if x && y {
+    ///     // …
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub COLLAPSIBLE_IF,
+    style,
+    "nested `if`s that can be collapsed (e.g., `if x { if y { ... } }`"
+}
+
+impl_lint_pass!(CollapsibleIf => [COLLAPSIBLE_ELSE_IF, COLLAPSIBLE_IF]);
+
 pub struct CollapsibleIf {
     msrv: Msrv,
     lint_commented_code: bool,
@@ -259,8 +261,6 @@ impl CollapsibleIf {
     }
 }
 
-impl_lint_pass!(CollapsibleIf => [COLLAPSIBLE_IF, COLLAPSIBLE_ELSE_IF]);
-
 impl LateLintPass<'_> for CollapsibleIf {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let ExprKind::If(cond, then, else_) = &expr.kind
diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index fd84ce70bd71..f9afdb0cabf9 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     nursery,
     "a collection is never queried"
 }
+
 declare_lint_pass!(CollectionIsNeverRead => [COLLECTION_IS_NEVER_READ]);
 
 impl<'tcx> LateLintPass<'tcx> for CollectionIsNeverRead {
diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index 19f62e8bf79c..509b345048c1 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -49,6 +49,7 @@ declare_clippy_lint! {
     suspicious,
     "using `crate` in a macro definition"
 }
+
 declare_lint_pass!(CrateInMacroDef => [CRATE_IN_MACRO_DEF]);
 
 impl EarlyLintPass for CrateInMacroDef {
diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index 45de4035d992..525f3da3efb1 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -33,6 +33,8 @@ declare_clippy_lint! {
     "`dbg!` macro is intended as a debugging tool"
 }
 
+impl_lint_pass!(DbgMacro => [DBG_MACRO]);
+
 pub struct DbgMacro {
     allow_dbg_in_tests: bool,
     /// Tracks the `dbg!` macro callsites that are already checked.
@@ -41,8 +43,6 @@ pub struct DbgMacro {
     prev_ctxt: SyntaxContext,
 }
 
-impl_lint_pass!(DbgMacro => [DBG_MACRO]);
-
 impl DbgMacro {
     pub fn new(conf: &'static Conf) -> Self {
         DbgMacro {
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index a48e4d2fbd57..2064d896861b 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -69,14 +69,14 @@ declare_clippy_lint! {
     "binding initialized with Default should have its fields set in the initializer"
 }
 
+impl_lint_pass!(Default => [DEFAULT_TRAIT_ACCESS, FIELD_REASSIGN_WITH_DEFAULT]);
+
 #[derive(Default)]
 pub struct Default {
     // Spans linted by `field_reassign_with_default`.
     reassigned_linted: FxHashSet<Span>,
 }
 
-impl_lint_pass!(Default => [DEFAULT_TRAIT_ACCESS, FIELD_REASSIGN_WITH_DEFAULT]);
-
 impl<'tcx> LateLintPass<'tcx> for Default {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion()
diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index 641f8ae03b72..c831f96443c6 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -45,7 +45,10 @@ declare_clippy_lint! {
     complexity,
     "unit structs can be constructed without calling `default`"
 }
-declare_lint_pass!(DefaultConstructedUnitStructs => [DEFAULT_CONSTRUCTED_UNIT_STRUCTS]);
+
+declare_lint_pass!(DefaultConstructedUnitStructs => [
+    DEFAULT_CONSTRUCTED_UNIT_STRUCTS,
+]);
 
 fn is_alias(ty: hir::Ty<'_>) -> bool {
     if let hir::TyKind::Path(ref qpath) = ty.kind {
diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
index 056e39c02af9..f041fc95fdd2 100644
--- a/clippy_lints/src/default_instead_of_iter_empty.rs
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     style,
     "check `std::iter::Empty::default()` and replace with `std::iter::empty()`"
 }
+
 declare_lint_pass!(DefaultIterEmpty => [DEFAULT_INSTEAD_OF_ITER_EMPTY]);
 
 impl<'tcx> LateLintPass<'tcx> for DefaultIterEmpty {
diff --git a/clippy_lints/src/default_union_representation.rs b/clippy_lints/src/default_union_representation.rs
index df6525ce040e..c04e07ee7f10 100644
--- a/clippy_lints/src/default_union_representation.rs
+++ b/clippy_lints/src/default_union_representation.rs
@@ -48,6 +48,7 @@ declare_clippy_lint! {
     restriction,
     "unions without a `#[repr(C)]` attribute"
 }
+
 declare_lint_pass!(DefaultUnionRepresentation => [DEFAULT_UNION_REPRESENTATION]);
 
 impl<'tcx> LateLintPass<'tcx> for DefaultUnionRepresentation {
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 32fd4afb122e..920200bf8263 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -23,6 +23,29 @@ use rustc_span::symbol::sym;
 use rustc_span::{Span, Symbol};
 use std::borrow::Cow;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for dereferencing expressions which would be covered by auto-deref.
+    ///
+    /// ### Why is this bad?
+    /// This unnecessarily complicates the code.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = String::new();
+    /// let y: &str = &*x;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x = String::new();
+    /// let y: &str = &x;
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub EXPLICIT_AUTO_DEREF,
+    complexity,
+    "dereferencing when the compiler would automatically dereference"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for explicit `deref()` or `deref_mut()` method calls.
@@ -120,34 +143,11 @@ declare_clippy_lint! {
     "`ref` binding to a reference"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for dereferencing expressions which would be covered by auto-deref.
-    ///
-    /// ### Why is this bad?
-    /// This unnecessarily complicates the code.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = String::new();
-    /// let y: &str = &*x;
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let x = String::new();
-    /// let y: &str = &x;
-    /// ```
-    #[clippy::version = "1.64.0"]
-    pub EXPLICIT_AUTO_DEREF,
-    complexity,
-    "dereferencing when the compiler would automatically dereference"
-}
-
 impl_lint_pass!(Dereferencing<'_> => [
+    EXPLICIT_AUTO_DEREF,
     EXPLICIT_DEREF_METHODS,
     NEEDLESS_BORROW,
     REF_BINDING_TO_REFERENCE,
-    EXPLICIT_AUTO_DEREF,
 ]);
 
 #[derive(Default)]
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 992ed320ce68..c04163b1c7a0 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -56,6 +56,8 @@ declare_clippy_lint! {
     "manual implementation of the `Default` trait which is equal to a derive"
 }
 
+impl_lint_pass!(DerivableImpls => [DERIVABLE_IMPLS]);
+
 pub struct DerivableImpls {
     msrv: Msrv,
 }
@@ -66,8 +68,6 @@ impl DerivableImpls {
     }
 }
 
-impl_lint_pass!(DerivableImpls => [DERIVABLE_IMPLS]);
-
 fn is_path_self(e: &Expr<'_>) -> bool {
     if let ExprKind::Path(QPath::Resolved(_, p)) = e.kind {
         matches!(p.res, Res::SelfCtor(..) | Res::Def(DefKind::Ctor(..), _))
diff --git a/clippy_lints/src/derive/mod.rs b/clippy_lints/src/derive/mod.rs
index 86614201c406..fa1a7037154e 100644
--- a/clippy_lints/src/derive/mod.rs
+++ b/clippy_lints/src/derive/mod.rs
@@ -10,36 +10,6 @@ mod derived_hash_with_manual_eq;
 mod expl_impl_clone_on_copy;
 mod unsafe_derive_deserialize;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lints against manual `PartialEq` implementations for types with a derived `Hash`
-    /// implementation.
-    ///
-    /// ### Why is this bad?
-    /// The implementation of these traits must agree (for
-    /// example for use with `HashMap`) so it’s probably a bad idea to use a
-    /// default-generated `Hash` implementation with an explicitly defined
-    /// `PartialEq`. In particular, the following must hold for any type:
-    ///
-    /// ```text
-    /// k1 == k2 ⇒ hash(k1) == hash(k2)
-    /// ```
-    ///
-    /// ### Example
-    /// ```ignore
-    /// #[derive(Hash)]
-    /// struct Foo;
-    ///
-    /// impl PartialEq for Foo {
-    ///     ...
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DERIVED_HASH_WITH_MANUAL_EQ,
-    correctness,
-    "deriving `Hash` but implementing `PartialEq` explicitly"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Lints against manual `PartialOrd` and `Ord` implementations for types with a derived `Ord`
@@ -91,6 +61,68 @@ declare_clippy_lint! {
     "deriving `Ord` but implementing `PartialOrd` explicitly"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for types that derive `PartialEq` and could implement `Eq`.
+    ///
+    /// ### Why is this bad?
+    /// If a type `T` derives `PartialEq` and all of its members implement `Eq`,
+    /// then `T` can always implement `Eq`. Implementing `Eq` allows `T` to be used
+    /// in APIs that require `Eq` types. It also allows structs containing `T` to derive
+    /// `Eq` themselves.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[derive(PartialEq)]
+    /// struct Foo {
+    ///     i_am_eq: i32,
+    ///     i_am_eq_too: Vec<String>,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #[derive(PartialEq, Eq)]
+    /// struct Foo {
+    ///     i_am_eq: i32,
+    ///     i_am_eq_too: Vec<String>,
+    /// }
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+    nursery,
+    "deriving `PartialEq` on a type that can implement `Eq`, without implementing `Eq`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lints against manual `PartialEq` implementations for types with a derived `Hash`
+    /// implementation.
+    ///
+    /// ### Why is this bad?
+    /// The implementation of these traits must agree (for
+    /// example for use with `HashMap`) so it’s probably a bad idea to use a
+    /// default-generated `Hash` implementation with an explicitly defined
+    /// `PartialEq`. In particular, the following must hold for any type:
+    ///
+    /// ```text
+    /// k1 == k2 ⇒ hash(k1) == hash(k2)
+    /// ```
+    ///
+    /// ### Example
+    /// ```ignore
+    /// #[derive(Hash)]
+    /// struct Foo;
+    ///
+    /// impl PartialEq for Foo {
+    ///     ...
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DERIVED_HASH_WITH_MANUAL_EQ,
+    correctness,
+    "deriving `Hash` but implementing `PartialEq` explicitly"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for explicit `Clone` implementations for `Copy`
@@ -152,44 +184,12 @@ declare_clippy_lint! {
     "deriving `serde::Deserialize` on a type that has methods using `unsafe`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for types that derive `PartialEq` and could implement `Eq`.
-    ///
-    /// ### Why is this bad?
-    /// If a type `T` derives `PartialEq` and all of its members implement `Eq`,
-    /// then `T` can always implement `Eq`. Implementing `Eq` allows `T` to be used
-    /// in APIs that require `Eq` types. It also allows structs containing `T` to derive
-    /// `Eq` themselves.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[derive(PartialEq)]
-    /// struct Foo {
-    ///     i_am_eq: i32,
-    ///     i_am_eq_too: Vec<String>,
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// #[derive(PartialEq, Eq)]
-    /// struct Foo {
-    ///     i_am_eq: i32,
-    ///     i_am_eq_too: Vec<String>,
-    /// }
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub DERIVE_PARTIAL_EQ_WITHOUT_EQ,
-    nursery,
-    "deriving `PartialEq` on a type that can implement `Eq`, without implementing `Eq`"
-}
-
 declare_lint_pass!(Derive => [
-    EXPL_IMPL_CLONE_ON_COPY,
     DERIVED_HASH_WITH_MANUAL_EQ,
     DERIVE_ORD_XOR_PARTIAL_ORD,
+    DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+    EXPL_IMPL_CLONE_ON_COPY,
     UNSAFE_DERIVE_DESERIALIZE,
-    DERIVE_PARTIAL_EQ_WITHOUT_EQ
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Derive {
diff --git a/clippy_lints/src/disallowed_fields.rs b/clippy_lints/src/disallowed_fields.rs
index f1136556e2ed..9873c32f427f 100644
--- a/clippy_lints/src/disallowed_fields.rs
+++ b/clippy_lints/src/disallowed_fields.rs
@@ -56,6 +56,8 @@ declare_clippy_lint! {
     "declaration of a disallowed field use"
 }
 
+impl_lint_pass!(DisallowedFields => [DISALLOWED_FIELDS]);
+
 pub struct DisallowedFields {
     disallowed: DefIdMap<(&'static str, &'static DisallowedPath)>,
 }
@@ -74,8 +76,6 @@ impl DisallowedFields {
     }
 }
 
-impl_lint_pass!(DisallowedFields => [DISALLOWED_FIELDS]);
-
 impl<'tcx> LateLintPass<'tcx> for DisallowedFields {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let (id, span) = match &expr.kind {
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 1c9c971730f6..7253b65e4337 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -63,6 +63,8 @@ declare_clippy_lint! {
     "use of a disallowed macro"
 }
 
+impl_lint_pass!(DisallowedMacros => [DISALLOWED_MACROS]);
+
 pub struct DisallowedMacros {
     disallowed: DefIdMap<(&'static str, &'static DisallowedPath)>,
     seen: FxHashSet<ExpnId>,
@@ -125,8 +127,6 @@ impl DisallowedMacros {
     }
 }
 
-impl_lint_pass!(DisallowedMacros => [DISALLOWED_MACROS]);
-
 impl LateLintPass<'_> for DisallowedMacros {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         // once we check a crate in the late pass we can emit the early pass lints
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index 58403ad19235..e2fd71b7d990 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -61,6 +61,8 @@ declare_clippy_lint! {
     "use of a disallowed method call"
 }
 
+impl_lint_pass!(DisallowedMethods => [DISALLOWED_METHODS]);
+
 pub struct DisallowedMethods {
     disallowed: DefIdMap<(&'static str, &'static DisallowedPath)>,
 }
@@ -84,8 +86,6 @@ impl DisallowedMethods {
     }
 }
 
-impl_lint_pass!(DisallowedMethods => [DISALLOWED_METHODS]);
-
 impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if expr.span.desugaring_kind().is_some() {
diff --git a/clippy_lints/src/disallowed_names.rs b/clippy_lints/src/disallowed_names.rs
index 566aa12b08f5..1f658b2aa068 100644
--- a/clippy_lints/src/disallowed_names.rs
+++ b/clippy_lints/src/disallowed_names.rs
@@ -26,6 +26,8 @@ declare_clippy_lint! {
     "usage of a disallowed/placeholder name"
 }
 
+impl_lint_pass!(DisallowedNames => [DISALLOWED_NAMES]);
+
 pub struct DisallowedNames {
     disallow: FxHashSet<Symbol>,
 }
@@ -38,8 +40,6 @@ impl DisallowedNames {
     }
 }
 
-impl_lint_pass!(DisallowedNames => [DISALLOWED_NAMES]);
-
 impl<'tcx> LateLintPass<'tcx> for DisallowedNames {
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
         if let PatKind::Binding(.., ident, _) = pat.kind
diff --git a/clippy_lints/src/disallowed_script_idents.rs b/clippy_lints/src/disallowed_script_idents.rs
index 5b4fe2a6b803..4596d9457c0b 100644
--- a/clippy_lints/src/disallowed_script_idents.rs
+++ b/clippy_lints/src/disallowed_script_idents.rs
@@ -45,6 +45,8 @@ declare_clippy_lint! {
     "usage of non-allowed Unicode scripts"
 }
 
+impl_lint_pass!(DisallowedScriptIdents => [DISALLOWED_SCRIPT_IDENTS]);
+
 pub struct DisallowedScriptIdents {
     whitelist: FxHashSet<Script>,
 }
@@ -62,8 +64,6 @@ impl DisallowedScriptIdents {
     }
 }
 
-impl_lint_pass!(DisallowedScriptIdents => [DISALLOWED_SCRIPT_IDENTS]);
-
 impl EarlyLintPass for DisallowedScriptIdents {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, _: &ast::Crate) {
         // Implementation is heavily inspired by the implementation of [`non_ascii_idents`] lint:
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
index 9a82327a0d7b..2c520d053f43 100644
--- a/clippy_lints/src/disallowed_types.rs
+++ b/clippy_lints/src/disallowed_types.rs
@@ -57,6 +57,8 @@ declare_clippy_lint! {
     "use of disallowed types"
 }
 
+impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
+
 pub struct DisallowedTypes {
     def_ids: DefIdMap<(&'static str, &'static DisallowedPath)>,
     prim_tys: FxHashMap<PrimTy, (&'static str, &'static DisallowedPath)>,
@@ -104,8 +106,6 @@ pub fn def_kind_predicate(def_kind: DefKind) -> bool {
     )
 }
 
-impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
-
 impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if let ItemKind::Use(path, UseKind::Single(_)) = &item.kind
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 0a2871f23964..a94133376cbf 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -41,236 +41,171 @@ mod too_long_first_doc_paragraph;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the presence of `_`, `::` or camel-case words
-    /// outside ticks in documentation.
+    /// Checks the doc comments have unbroken links, mostly caused
+    /// by bad formatted links such as broken across multiple lines.
     ///
     /// ### Why is this bad?
-    /// *Rustdoc* supports markdown formatting, `_`, `::` and
-    /// camel-case probably indicates some code which should be included between
-    /// ticks. `_` can also be used for emphasis in markdown, this lint tries to
-    /// consider that.
-    ///
-    /// ### Known problems
-    /// Lots of bad docs won’t be fixed, what the lint checks
-    /// for is limited, and there are still false positives. HTML elements and their
-    /// content are not linted.
-    ///
-    /// In addition, when writing documentation comments, including `[]` brackets
-    /// inside a link text would trip the parser. Therefore, documenting link with
-    /// `[`SmallVec<[T; INLINE_CAPACITY]>`]` and then [`SmallVec<[T; INLINE_CAPACITY]>`]: SmallVec
-    /// would fail.
+    /// Because documentation generated by rustdoc will be broken
+    /// since expected links won't be links and just text.
     ///
     /// ### Examples
+    /// This link is broken:
     /// ```no_run
-    /// /// Do something with the foo_bar parameter. See also
-    /// /// that::other::module::foo.
-    /// // ^ `foo_bar` and `that::other::module::foo` should be ticked.
-    /// fn doit(foo_bar: usize) {}
+    /// /// [example of a bad link](https://
+    /// /// github.com/rust-lang/rust-clippy/)
+    /// pub fn do_something() {}
     /// ```
     ///
+    /// It shouldn't be broken across multiple lines to work:
     /// ```no_run
-    /// // Link text with `[]` brackets should be written as following:
-    /// /// Consume the array and return the inner
-    /// /// [`SmallVec<[T; INLINE_CAPACITY]>`][SmallVec].
-    /// /// [SmallVec]: SmallVec
-    /// fn main() {}
+    /// /// [example of a good link](https://github.com/rust-lang/rust-clippy/)
+    /// pub fn do_something() {}
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DOC_MARKDOWN,
+    #[clippy::version = "1.90.0"]
+    pub DOC_BROKEN_LINK,
     pedantic,
-    "presence of `_`, `::` or camel-case outside backticks in documentation"
+    "broken document link"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for links with code directly adjacent to code text:
-    /// `` [`MyItem`]`<`[`u32`]`>` ``.
+    /// Detects doc comment linebreaks that use double spaces to separate lines, instead of back-slash (`\`).
     ///
     /// ### Why is this bad?
-    /// It can be written more simply using HTML-style `<code>` tags.
+    /// Double spaces, when used as doc comment linebreaks, can be difficult to see, and may
+    /// accidentally be removed during automatic formatting or manual refactoring. The use of a back-slash (`\`)
+    /// is clearer in this regard.
     ///
     /// ### Example
+    /// The two replacement dots in this example represent a double space.
     /// ```no_run
-    /// //! [`first`](x)`second`
+    /// /// This command takes two numbers as inputs and··
+    /// /// adds them together, and then returns the result.
+    /// fn add(l: i32, r: i32) -> i32 {
+    ///     l + r
+    /// }
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// //! <code>[first](x)second</code>
+    /// /// This command takes two numbers as inputs and\
+    /// /// adds them together, and then returns the result.
+    /// fn add(l: i32, r: i32) -> i32 {
+    ///     l + r
+    /// }
     /// ```
     #[clippy::version = "1.87.0"]
-    pub DOC_LINK_CODE,
-    nursery,
-    "link with code back-to-back with other code"
+    pub DOC_COMMENT_DOUBLE_SPACE_LINEBREAKS,
+    pedantic,
+    "double-space used for doc comment linebreak instead of `\\`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the doc comments of publicly visible
-    /// unsafe functions and warns if there is no `# Safety` section.
+    /// Checks if included files in doc comments are included only for `cfg(doc)`.
     ///
-    /// ### Why is this bad?
-    /// Unsafe functions should document their safety
-    /// preconditions, so that users can be sure they are using them safely.
+    /// ### Why restrict this?
+    /// These files are not useful for compilation but will still be included.
+    /// Also, if any of these non-source code file is updated, it will trigger a
+    /// recompilation.
     ///
-    /// ### Examples
-    /// ```no_run
-    ///# type Universe = ();
-    /// /// This function should really be documented
-    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
-    /// ```
+    /// ### Known problems
     ///
-    /// At least write a line about safety:
+    /// Excluding this will currently result in the file being left out if
+    /// the item's docs are inlined from another crate. This may be fixed in a
+    /// future version of rustdoc.
     ///
+    /// ### Example
+    /// ```ignore
+    /// #![doc = include_str!("some_file.md")]
+    /// ```
+    /// Use instead:
     /// ```no_run
-    ///# type Universe = ();
-    /// /// # Safety
-    /// ///
-    /// /// This function should not be called before the horsemen are ready.
-    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
+    /// #![cfg_attr(doc, doc = include_str!("some_file.md"))]
     /// ```
-    #[clippy::version = "1.39.0"]
-    pub MISSING_SAFETY_DOC,
-    style,
-    "`pub unsafe fn` without `# Safety` docs"
+    #[clippy::version = "1.85.0"]
+    pub DOC_INCLUDE_WITHOUT_CFG,
+    restriction,
+    "check if files included in documentation are behind `cfg(doc)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks the doc comments of publicly visible functions that
-    /// return a `Result` type and warns if there is no `# Errors` section.
+    ///
+    /// In CommonMark Markdown, the language used to write doc comments, a
+    /// paragraph nested within a list or block quote does not need any line
+    /// after the first one to be indented or marked. The specification calls
+    /// this a "lazy paragraph continuation."
     ///
     /// ### Why is this bad?
-    /// Documenting the type of errors that can be returned from a
-    /// function can help callers write code to handle the errors appropriately.
     ///
-    /// ### Examples
-    /// Since the following function returns a `Result` it has an `# Errors` section in
-    /// its doc comment:
+    /// This is easy to write but hard to read. Lazy continuations makes
+    /// unintended markers hard to see, and make it harder to deduce the
+    /// document's intended structure.
     ///
+    /// ### Example
+    ///
+    /// This table is probably intended to have two rows,
+    /// but it does not. It has zero rows, and is followed by
+    /// a block quote.
     /// ```no_run
-    ///# use std::io;
-    /// /// # Errors
-    /// ///
-    /// /// Will return `Err` if `filename` does not exist or the user does not have
-    /// /// permission to read it.
-    /// pub fn read(filename: String) -> io::Result<String> {
-    ///     unimplemented!();
-    /// }
+    /// /// Range | Description
+    /// /// ----- | -----------
+    /// /// >= 1  | fully opaque
+    /// /// < 1   | partially see-through
+    /// fn set_opacity(opacity: f32) {}
     /// ```
-    #[clippy::version = "1.41.0"]
-    pub MISSING_ERRORS_DOC,
-    pedantic,
-    "`pub fn` returns `Result` without `# Errors` in doc comment"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks the doc comments of publicly visible functions that
-    /// may panic and warns if there is no `# Panics` section.
-    ///
-    /// ### Why is this bad?
-    /// Documenting the scenarios in which panicking occurs
-    /// can help callers who do not want to panic to avoid those situations.
-    ///
-    /// ### Examples
-    /// Since the following function may panic it has a `# Panics` section in
-    /// its doc comment:
     ///
+    /// Fix it by escaping the marker:
     /// ```no_run
-    /// /// # Panics
-    /// ///
-    /// /// Will panic if y is 0
-    /// pub fn divide_by(x: i32, y: i32) -> i32 {
-    ///     if y == 0 {
-    ///         panic!("Cannot divide by 0")
-    ///     } else {
-    ///         x / y
-    ///     }
-    /// }
+    /// /// Range | Description
+    /// /// ----- | -----------
+    /// /// \>= 1 | fully opaque
+    /// /// < 1   | partially see-through
+    /// fn set_opacity(opacity: f32) {}
     /// ```
     ///
-    /// Individual panics within a function can be ignored with `#[expect]` or
-    /// `#[allow]`:
-    ///
+    /// This example is actually intended to be a list:
     /// ```no_run
-    /// # use std::num::NonZeroUsize;
-    /// pub fn will_not_panic(x: usize) {
-    ///     #[expect(clippy::missing_panics_doc, reason = "infallible")]
-    ///     let y = NonZeroUsize::new(1).unwrap();
-    ///
-    ///     // If any panics are added in the future the lint will still catch them
-    /// }
+    /// /// * Do nothing.
+    /// /// * Then do something. Whatever it is needs done,
+    /// /// it should be done right now.
+    /// # fn do_stuff() {}
     /// ```
-    #[clippy::version = "1.51.0"]
-    pub MISSING_PANICS_DOC,
-    pedantic,
-    "`pub fn` may panic without `# Panics` in doc comment"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `fn main() { .. }` in doctests
-    ///
-    /// ### Why is this bad?
-    /// The test can be shorter (and likely more readable)
-    /// if the `fn main()` is left implicit.
     ///
-    /// ### Examples
+    /// Fix it by indenting the list contents:
     /// ```no_run
-    /// /// An example of a doctest with a `main()` function
-    /// ///
-    /// /// # Examples
-    /// ///
-    /// /// ```
-    /// /// fn main() {
-    /// ///     // this needs not be in an `fn`
-    /// /// }
-    /// /// ```
-    /// fn needless_main() {
-    ///     unimplemented!();
-    /// }
+    /// /// * Do nothing.
+    /// /// * Then do something. Whatever it is needs done,
+    /// ///   it should be done right now.
+    /// # fn do_stuff() {}
     /// ```
-    #[clippy::version = "1.40.0"]
-    pub NEEDLESS_DOCTEST_MAIN,
+    #[clippy::version = "1.80.0"]
+    pub DOC_LAZY_CONTINUATION,
     style,
-    "presence of `fn main() {` in code examples"
+    "require every line of a paragraph to be indented and marked"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `#[test]` in doctests unless they are marked with
-    /// either `ignore`, `no_run` or `compile_fail`.
+    /// Checks for links with code directly adjacent to code text:
+    /// `` [`MyItem`]`<`[`u32`]`>` ``.
     ///
     /// ### Why is this bad?
-    /// Code in examples marked as `#[test]` will somewhat
-    /// surprisingly not be run by `cargo test`. If you really want
-    /// to show how to test stuff in an example, mark it `no_run` to
-    /// make the intent clear.
+    /// It can be written more simply using HTML-style `<code>` tags.
     ///
-    /// ### Examples
+    /// ### Example
     /// ```no_run
-    /// /// An example of a doctest with a `main()` function
-    /// ///
-    /// /// # Examples
-    /// ///
-    /// /// ```
-    /// /// #[test]
-    /// /// fn equality_works() {
-    /// ///     assert_eq!(1_u8, 1);
-    /// /// }
-    /// /// ```
-    /// fn test_attr_in_doctest() {
-    ///     unimplemented!();
-    /// }
+    /// //! [`first`](x)`second`
     /// ```
-    #[clippy::version = "1.76.0"]
-    pub TEST_ATTR_IN_DOCTEST,
-    suspicious,
-    "presence of `#[test]` in code examples"
+    /// Use instead:
+    /// ```no_run
+    /// //! <code>[first](x)second</code>
+    /// ```
+    #[clippy::version = "1.87.0"]
+    pub DOC_LINK_CODE,
+    nursery,
+    "link with code back-to-back with other code"
 }
 
 declare_clippy_lint! {
@@ -298,113 +233,167 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks the doc comments have unbroken links, mostly caused
-    /// by bad formatted links such as broken across multiple lines.
+    /// Checks for the presence of `_`, `::` or camel-case words
+    /// outside ticks in documentation.
     ///
     /// ### Why is this bad?
-    /// Because documentation generated by rustdoc will be broken
-    /// since expected links won't be links and just text.
+    /// *Rustdoc* supports markdown formatting, `_`, `::` and
+    /// camel-case probably indicates some code which should be included between
+    /// ticks. `_` can also be used for emphasis in markdown, this lint tries to
+    /// consider that.
+    ///
+    /// ### Known problems
+    /// Lots of bad docs won’t be fixed, what the lint checks
+    /// for is limited, and there are still false positives. HTML elements and their
+    /// content are not linted.
+    ///
+    /// In addition, when writing documentation comments, including `[]` brackets
+    /// inside a link text would trip the parser. Therefore, documenting link with
+    /// `[`SmallVec<[T; INLINE_CAPACITY]>`]` and then [`SmallVec<[T; INLINE_CAPACITY]>`]: SmallVec
+    /// would fail.
     ///
     /// ### Examples
-    /// This link is broken:
     /// ```no_run
-    /// /// [example of a bad link](https://
-    /// /// github.com/rust-lang/rust-clippy/)
-    /// pub fn do_something() {}
+    /// /// Do something with the foo_bar parameter. See also
+    /// /// that::other::module::foo.
+    /// // ^ `foo_bar` and `that::other::module::foo` should be ticked.
+    /// fn doit(foo_bar: usize) {}
     /// ```
     ///
-    /// It shouldn't be broken across multiple lines to work:
     /// ```no_run
-    /// /// [example of a good link](https://github.com/rust-lang/rust-clippy/)
-    /// pub fn do_something() {}
+    /// // Link text with `[]` brackets should be written as following:
+    /// /// Consume the array and return the inner
+    /// /// [`SmallVec<[T; INLINE_CAPACITY]>`][SmallVec].
+    /// /// [SmallVec]: SmallVec
+    /// fn main() {}
     /// ```
-    #[clippy::version = "1.90.0"]
-    pub DOC_BROKEN_LINK,
+    #[clippy::version = "pre 1.29.0"]
+    pub DOC_MARKDOWN,
     pedantic,
-    "broken document link"
+    "presence of `_`, `::` or camel-case outside backticks in documentation"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the doc comments of publicly visible
-    /// safe functions and traits and warns if there is a `# Safety` section.
+    /// Warns if a link reference definition appears at the start of a
+    /// list item or quote.
     ///
-    /// ### Why restrict this?
-    /// Safe functions and traits are safe to implement and therefore do not
-    /// need to describe safety preconditions that users are required to uphold.
+    /// ### Why is this bad?
+    /// This is probably intended as an intra-doc link. If it is really
+    /// supposed to be a reference definition, it can be written outside
+    /// of the list item or quote.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// //! - [link]: description
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// //! - [link][]: description (for intra-doc link)
+    /// //!
+    /// //! [link]: destination (for link reference definition)
+    /// ```
+    #[clippy::version = "1.85.0"]
+    pub DOC_NESTED_REFDEFS,
+    suspicious,
+    "link reference defined in list item or quote"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Detects overindented list items in doc comments where the continuation
+    /// lines are indented more than necessary.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Overindented list items in doc comments can lead to inconsistent and
+    /// poorly formatted documentation when rendered. Excessive indentation may
+    /// cause the text to be misinterpreted as a nested list item or code block,
+    /// affecting readability and the overall structure of the documentation.
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// /// - This is the first item in a list
+    /// ///      and this line is overindented.
+    /// # fn foo() {}
+    /// ```
+    ///
+    /// Fixes this into:
+    /// ```no_run
+    /// /// - This is the first item in a list
+    /// ///   and this line is overindented.
+    /// # fn foo() {}
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub DOC_OVERINDENTED_LIST_ITEMS,
+    style,
+    "ensure list items are not overindented"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for doc comments whose paragraphs do not end with a period or another punctuation mark.
+    /// Various Markdowns constructs are taken into account to avoid false positives.
+    ///
+    /// ### Why is this bad?
+    /// A project may wish to enforce consistent doc comments by making sure paragraphs end with a
+    /// punctuation mark.
     ///
-    /// ### Examples
+    /// ### Example
     /// ```no_run
-    ///# type Universe = ();
-    /// /// # Safety
+    /// /// Returns a random number
     /// ///
-    /// /// This function should not be called before the horsemen are ready.
-    /// pub fn start_apocalypse_but_safely(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
+    /// /// It was chosen by a fair dice roll
     /// ```
-    ///
-    /// The function is safe, so there shouldn't be any preconditions
-    /// that have to be explained for safety reasons.
-    ///
+    /// Use instead:
     /// ```no_run
-    ///# type Universe = ();
-    /// /// This function should really be documented
-    /// pub fn start_apocalypse(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
+    /// /// Returns a random number.
+    /// ///
+    /// /// It was chosen by a fair dice roll.
     /// ```
-    #[clippy::version = "1.67.0"]
-    pub UNNECESSARY_SAFETY_DOC,
+    ///
+    /// ### Terminal punctuation marks
+    /// This lint treats these characters as end markers: '.', '?', '!', '…' and ':'.
+    ///
+    /// The colon is not exactly a terminal punctuation mark, but this is required for paragraphs that
+    /// introduce a table or a list for example.
+    #[clippy::version = "1.93.0"]
+    pub DOC_PARAGRAPHS_MISSING_PUNCTUATION,
     restriction,
-    "`pub fn` or `pub trait` with `# Safety` docs"
+    "missing terminal punctuation in doc comments"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detects the use of outer doc comments (`///`, `/**`) followed by a bang (`!`): `///!`
-    ///
-    /// ### Why is this bad?
-    /// Triple-slash comments (known as "outer doc comments") apply to items that follow it.
-    /// An outer doc comment followed by a bang (i.e. `///!`) has no specific meaning.
+    /// Detects syntax that looks like a footnote reference.
     ///
-    /// The user most likely meant to write an inner doc comment (`//!`, `/*!`), which
-    /// applies to the parent item (i.e. the item that the comment is contained in,
-    /// usually a module or crate).
+    /// Rustdoc footnotes are compatible with GitHub-Flavored Markdown (GFM).
+    /// GFM does not parse a footnote reference unless its definition also
+    /// exists. This lint checks for footnote references with missing
+    /// definitions, unless it thinks you're writing a regex.
     ///
-    /// ### Known problems
-    /// Inner doc comments can only appear before items, so there are certain cases where the suggestion
-    /// made by this lint is not valid code. For example:
-    /// ```rust
-    /// fn foo() {}
-    /// ///!
-    /// fn bar() {}
-    /// ```
-    /// This lint detects the doc comment and suggests changing it to `//!`, but an inner doc comment
-    /// is not valid at that position.
+    /// ### Why is this bad?
+    /// This probably means that a footnote was meant to exist,
+    /// but was not written.
     ///
     /// ### Example
-    /// In this example, the doc comment is attached to the *function*, rather than the *module*.
     /// ```no_run
-    /// pub mod util {
-    ///     ///! This module contains utility functions.
-    ///
-    ///     pub fn dummy() {}
-    /// }
+    /// /// This is not a footnote[^1], because no definition exists.
+    /// fn my_fn() {}
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// pub mod util {
-    ///     //! This module contains utility functions.
-    ///
-    ///     pub fn dummy() {}
-    /// }
+    /// /// This is a footnote[^1].
+    /// ///
+    /// /// [^1]: defined here
+    /// fn my_fn() {}
     /// ```
-    #[clippy::version = "1.70.0"]
-    pub SUSPICIOUS_DOC_COMMENTS,
+    #[clippy::version = "1.89.0"]
+    pub DOC_SUSPICIOUS_FOOTNOTES,
     suspicious,
-    "suspicious usage of (outer) doc comments"
+    "looks like a link or footnote ref, but with no definition"
 }
 
 declare_clippy_lint! {
@@ -433,277 +422,311 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// In CommonMark Markdown, the language used to write doc comments, a
-    /// paragraph nested within a list or block quote does not need any line
-    /// after the first one to be indented or marked. The specification calls
-    /// this a "lazy paragraph continuation."
+    /// Checks the doc comments of publicly visible functions that
+    /// return a `Result` type and warns if there is no `# Errors` section.
     ///
     /// ### Why is this bad?
+    /// Documenting the type of errors that can be returned from a
+    /// function can help callers write code to handle the errors appropriately.
     ///
-    /// This is easy to write but hard to read. Lazy continuations makes
-    /// unintended markers hard to see, and make it harder to deduce the
-    /// document's intended structure.
-    ///
-    /// ### Example
-    ///
-    /// This table is probably intended to have two rows,
-    /// but it does not. It has zero rows, and is followed by
-    /// a block quote.
-    /// ```no_run
-    /// /// Range | Description
-    /// /// ----- | -----------
-    /// /// >= 1  | fully opaque
-    /// /// < 1   | partially see-through
-    /// fn set_opacity(opacity: f32) {}
-    /// ```
-    ///
-    /// Fix it by escaping the marker:
-    /// ```no_run
-    /// /// Range | Description
-    /// /// ----- | -----------
-    /// /// \>= 1 | fully opaque
-    /// /// < 1   | partially see-through
-    /// fn set_opacity(opacity: f32) {}
-    /// ```
-    ///
-    /// This example is actually intended to be a list:
-    /// ```no_run
-    /// /// * Do nothing.
-    /// /// * Then do something. Whatever it is needs done,
-    /// /// it should be done right now.
-    /// # fn do_stuff() {}
-    /// ```
+    /// ### Examples
+    /// Since the following function returns a `Result` it has an `# Errors` section in
+    /// its doc comment:
     ///
-    /// Fix it by indenting the list contents:
     /// ```no_run
-    /// /// * Do nothing.
-    /// /// * Then do something. Whatever it is needs done,
-    /// ///   it should be done right now.
-    /// # fn do_stuff() {}
+    ///# use std::io;
+    /// /// # Errors
+    /// ///
+    /// /// Will return `Err` if `filename` does not exist or the user does not have
+    /// /// permission to read it.
+    /// pub fn read(filename: String) -> io::Result<String> {
+    ///     unimplemented!();
+    /// }
     /// ```
-    #[clippy::version = "1.80.0"]
-    pub DOC_LAZY_CONTINUATION,
-    style,
-    "require every line of a paragraph to be indented and marked"
+    #[clippy::version = "1.41.0"]
+    pub MISSING_ERRORS_DOC,
+    pedantic,
+    "`pub fn` returns `Result` without `# Errors` in doc comment"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Detects overindented list items in doc comments where the continuation
-    /// lines are indented more than necessary.
+    /// Checks the doc comments of publicly visible functions that
+    /// may panic and warns if there is no `# Panics` section.
     ///
     /// ### Why is this bad?
+    /// Documenting the scenarios in which panicking occurs
+    /// can help callers who do not want to panic to avoid those situations.
     ///
-    /// Overindented list items in doc comments can lead to inconsistent and
-    /// poorly formatted documentation when rendered. Excessive indentation may
-    /// cause the text to be misinterpreted as a nested list item or code block,
-    /// affecting readability and the overall structure of the documentation.
-    ///
-    /// ### Example
+    /// ### Examples
+    /// Since the following function may panic it has a `# Panics` section in
+    /// its doc comment:
     ///
     /// ```no_run
-    /// /// - This is the first item in a list
-    /// ///      and this line is overindented.
-    /// # fn foo() {}
+    /// /// # Panics
+    /// ///
+    /// /// Will panic if y is 0
+    /// pub fn divide_by(x: i32, y: i32) -> i32 {
+    ///     if y == 0 {
+    ///         panic!("Cannot divide by 0")
+    ///     } else {
+    ///         x / y
+    ///     }
+    /// }
     /// ```
     ///
-    /// Fixes this into:
+    /// Individual panics within a function can be ignored with `#[expect]` or
+    /// `#[allow]`:
+    ///
     /// ```no_run
-    /// /// - This is the first item in a list
-    /// ///   and this line is overindented.
-    /// # fn foo() {}
+    /// # use std::num::NonZeroUsize;
+    /// pub fn will_not_panic(x: usize) {
+    ///     #[expect(clippy::missing_panics_doc, reason = "infallible")]
+    ///     let y = NonZeroUsize::new(1).unwrap();
+    ///
+    ///     // If any panics are added in the future the lint will still catch them
+    /// }
     /// ```
-    #[clippy::version = "1.86.0"]
-    pub DOC_OVERINDENTED_LIST_ITEMS,
-    style,
-    "ensure list items are not overindented"
+    #[clippy::version = "1.51.0"]
+    pub MISSING_PANICS_DOC,
+    pedantic,
+    "`pub fn` may panic without `# Panics` in doc comment"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks if the first paragraph in the documentation of items listed in the module page is too long.
+    /// Checks for the doc comments of publicly visible
+    /// unsafe functions and warns if there is no `# Safety` section.
     ///
     /// ### Why is this bad?
-    /// Documentation will show the first paragraph of the docstring in the summary page of a
-    /// module. Having a nice, short summary in the first paragraph is part of writing good docs.
+    /// Unsafe functions should document their safety
+    /// preconditions, so that users can be sure they are using them safely.
     ///
-    /// ### Example
-    /// ```no_run
-    /// /// A very short summary.
-    /// /// A much longer explanation that goes into a lot more detail about
-    /// /// how the thing works, possibly with doclinks and so one,
-    /// /// and probably spanning a many rows.
-    /// struct Foo {}
-    /// ```
-    /// Use instead:
+    /// ### Examples
     /// ```no_run
-    /// /// A very short summary.
-    /// ///
-    /// /// A much longer explanation that goes into a lot more detail about
-    /// /// how the thing works, possibly with doclinks and so one,
-    /// /// and probably spanning a many rows.
-    /// struct Foo {}
+    ///# type Universe = ();
+    /// /// This function should really be documented
+    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
     /// ```
-    #[clippy::version = "1.82.0"]
-    pub TOO_LONG_FIRST_DOC_PARAGRAPH,
-    nursery,
-    "ensure the first documentation paragraph is short"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks if included files in doc comments are included only for `cfg(doc)`.
-    ///
-    /// ### Why restrict this?
-    /// These files are not useful for compilation but will still be included.
-    /// Also, if any of these non-source code file is updated, it will trigger a
-    /// recompilation.
-    ///
-    /// ### Known problems
-    ///
-    /// Excluding this will currently result in the file being left out if
-    /// the item's docs are inlined from another crate. This may be fixed in a
-    /// future version of rustdoc.
     ///
-    /// ### Example
-    /// ```ignore
-    /// #![doc = include_str!("some_file.md")]
-    /// ```
-    /// Use instead:
+    /// At least write a line about safety:
+    ///
     /// ```no_run
-    /// #![cfg_attr(doc, doc = include_str!("some_file.md"))]
+    ///# type Universe = ();
+    /// /// # Safety
+    /// ///
+    /// /// This function should not be called before the horsemen are ready.
+    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
     /// ```
-    #[clippy::version = "1.85.0"]
-    pub DOC_INCLUDE_WITHOUT_CFG,
-    restriction,
-    "check if files included in documentation are behind `cfg(doc)`"
+    #[clippy::version = "1.39.0"]
+    pub MISSING_SAFETY_DOC,
+    style,
+    "`pub unsafe fn` without `# Safety` docs"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns if a link reference definition appears at the start of a
-    /// list item or quote.
+    /// Checks for `fn main() { .. }` in doctests
     ///
     /// ### Why is this bad?
-    /// This is probably intended as an intra-doc link. If it is really
-    /// supposed to be a reference definition, it can be written outside
-    /// of the list item or quote.
+    /// The test can be shorter (and likely more readable)
+    /// if the `fn main()` is left implicit.
     ///
-    /// ### Example
-    /// ```no_run
-    /// //! - [link]: description
-    /// ```
-    /// Use instead:
+    /// ### Examples
     /// ```no_run
-    /// //! - [link][]: description (for intra-doc link)
-    /// //!
-    /// //! [link]: destination (for link reference definition)
+    /// /// An example of a doctest with a `main()` function
+    /// ///
+    /// /// # Examples
+    /// ///
+    /// /// ```
+    /// /// fn main() {
+    /// ///     // this needs not be in an `fn`
+    /// /// }
+    /// /// ```
+    /// fn needless_main() {
+    ///     unimplemented!();
+    /// }
     /// ```
-    #[clippy::version = "1.85.0"]
-    pub DOC_NESTED_REFDEFS,
-    suspicious,
-    "link reference defined in list item or quote"
+    #[clippy::version = "1.40.0"]
+    pub NEEDLESS_DOCTEST_MAIN,
+    style,
+    "presence of `fn main() {` in code examples"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detects doc comment linebreaks that use double spaces to separate lines, instead of back-slash (`\`).
+    /// Detects the use of outer doc comments (`///`, `/**`) followed by a bang (`!`): `///!`
     ///
     /// ### Why is this bad?
-    /// Double spaces, when used as doc comment linebreaks, can be difficult to see, and may
-    /// accidentally be removed during automatic formatting or manual refactoring. The use of a back-slash (`\`)
-    /// is clearer in this regard.
+    /// Triple-slash comments (known as "outer doc comments") apply to items that follow it.
+    /// An outer doc comment followed by a bang (i.e. `///!`) has no specific meaning.
+    ///
+    /// The user most likely meant to write an inner doc comment (`//!`, `/*!`), which
+    /// applies to the parent item (i.e. the item that the comment is contained in,
+    /// usually a module or crate).
+    ///
+    /// ### Known problems
+    /// Inner doc comments can only appear before items, so there are certain cases where the suggestion
+    /// made by this lint is not valid code. For example:
+    /// ```rust
+    /// fn foo() {}
+    /// ///!
+    /// fn bar() {}
+    /// ```
+    /// This lint detects the doc comment and suggests changing it to `//!`, but an inner doc comment
+    /// is not valid at that position.
     ///
     /// ### Example
-    /// The two replacement dots in this example represent a double space.
+    /// In this example, the doc comment is attached to the *function*, rather than the *module*.
     /// ```no_run
-    /// /// This command takes two numbers as inputs and··
-    /// /// adds them together, and then returns the result.
-    /// fn add(l: i32, r: i32) -> i32 {
-    ///     l + r
+    /// pub mod util {
+    ///     ///! This module contains utility functions.
+    ///
+    ///     pub fn dummy() {}
     /// }
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// /// This command takes two numbers as inputs and\
-    /// /// adds them together, and then returns the result.
-    /// fn add(l: i32, r: i32) -> i32 {
-    ///     l + r
+    /// pub mod util {
+    ///     //! This module contains utility functions.
+    ///
+    ///     pub fn dummy() {}
     /// }
     /// ```
-    #[clippy::version = "1.87.0"]
-    pub DOC_COMMENT_DOUBLE_SPACE_LINEBREAKS,
-    pedantic,
-    "double-space used for doc comment linebreak instead of `\\`"
+    #[clippy::version = "1.70.0"]
+    pub SUSPICIOUS_DOC_COMMENTS,
+    suspicious,
+    "suspicious usage of (outer) doc comments"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detects syntax that looks like a footnote reference.
-    ///
-    /// Rustdoc footnotes are compatible with GitHub-Flavored Markdown (GFM).
-    /// GFM does not parse a footnote reference unless its definition also
-    /// exists. This lint checks for footnote references with missing
-    /// definitions, unless it thinks you're writing a regex.
+    /// Checks for `#[test]` in doctests unless they are marked with
+    /// either `ignore`, `no_run` or `compile_fail`.
     ///
     /// ### Why is this bad?
-    /// This probably means that a footnote was meant to exist,
-    /// but was not written.
+    /// Code in examples marked as `#[test]` will somewhat
+    /// surprisingly not be run by `cargo test`. If you really want
+    /// to show how to test stuff in an example, mark it `no_run` to
+    /// make the intent clear.
     ///
-    /// ### Example
-    /// ```no_run
-    /// /// This is not a footnote[^1], because no definition exists.
-    /// fn my_fn() {}
-    /// ```
-    /// Use instead:
+    /// ### Examples
     /// ```no_run
-    /// /// This is a footnote[^1].
+    /// /// An example of a doctest with a `main()` function
     /// ///
-    /// /// [^1]: defined here
-    /// fn my_fn() {}
+    /// /// # Examples
+    /// ///
+    /// /// ```
+    /// /// #[test]
+    /// /// fn equality_works() {
+    /// ///     assert_eq!(1_u8, 1);
+    /// /// }
+    /// /// ```
+    /// fn test_attr_in_doctest() {
+    ///     unimplemented!();
+    /// }
     /// ```
-    #[clippy::version = "1.89.0"]
-    pub DOC_SUSPICIOUS_FOOTNOTES,
+    #[clippy::version = "1.76.0"]
+    pub TEST_ATTR_IN_DOCTEST,
     suspicious,
-    "looks like a link or footnote ref, but with no definition"
+    "presence of `#[test]` in code examples"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for doc comments whose paragraphs do not end with a period or another punctuation mark.
-    /// Various Markdowns constructs are taken into account to avoid false positives.
+    /// Checks if the first paragraph in the documentation of items listed in the module page is too long.
     ///
     /// ### Why is this bad?
-    /// A project may wish to enforce consistent doc comments by making sure paragraphs end with a
-    /// punctuation mark.
+    /// Documentation will show the first paragraph of the docstring in the summary page of a
+    /// module. Having a nice, short summary in the first paragraph is part of writing good docs.
     ///
     /// ### Example
     /// ```no_run
-    /// /// Returns a random number
-    /// ///
-    /// /// It was chosen by a fair dice roll
+    /// /// A very short summary.
+    /// /// A much longer explanation that goes into a lot more detail about
+    /// /// how the thing works, possibly with doclinks and so one,
+    /// /// and probably spanning a many rows.
+    /// struct Foo {}
     /// ```
     /// Use instead:
     /// ```no_run
-    /// /// Returns a random number.
+    /// /// A very short summary.
     /// ///
-    /// /// It was chosen by a fair dice roll.
+    /// /// A much longer explanation that goes into a lot more detail about
+    /// /// how the thing works, possibly with doclinks and so one,
+    /// /// and probably spanning a many rows.
+    /// struct Foo {}
     /// ```
+    #[clippy::version = "1.82.0"]
+    pub TOO_LONG_FIRST_DOC_PARAGRAPH,
+    nursery,
+    "ensure the first documentation paragraph is short"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the doc comments of publicly visible
+    /// safe functions and traits and warns if there is a `# Safety` section.
     ///
-    /// ### Terminal punctuation marks
-    /// This lint treats these characters as end markers: '.', '?', '!', '…' and ':'.
+    /// ### Why restrict this?
+    /// Safe functions and traits are safe to implement and therefore do not
+    /// need to describe safety preconditions that users are required to uphold.
     ///
-    /// The colon is not exactly a terminal punctuation mark, but this is required for paragraphs that
-    /// introduce a table or a list for example.
-    #[clippy::version = "1.93.0"]
-    pub DOC_PARAGRAPHS_MISSING_PUNCTUATION,
+    /// ### Examples
+    /// ```no_run
+    ///# type Universe = ();
+    /// /// # Safety
+    /// ///
+    /// /// This function should not be called before the horsemen are ready.
+    /// pub fn start_apocalypse_but_safely(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    ///
+    /// The function is safe, so there shouldn't be any preconditions
+    /// that have to be explained for safety reasons.
+    ///
+    /// ```no_run
+    ///# type Universe = ();
+    /// /// This function should really be documented
+    /// pub fn start_apocalypse(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    #[clippy::version = "1.67.0"]
+    pub UNNECESSARY_SAFETY_DOC,
     restriction,
-    "missing terminal punctuation in doc comments"
+    "`pub fn` or `pub trait` with `# Safety` docs"
 }
 
+impl_lint_pass!(Documentation => [
+    DOC_BROKEN_LINK,
+    DOC_COMMENT_DOUBLE_SPACE_LINEBREAKS,
+    DOC_INCLUDE_WITHOUT_CFG,
+    DOC_LAZY_CONTINUATION,
+    DOC_LINK_CODE,
+    DOC_LINK_WITH_QUOTES,
+    DOC_MARKDOWN,
+    DOC_NESTED_REFDEFS,
+    DOC_OVERINDENTED_LIST_ITEMS,
+    DOC_PARAGRAPHS_MISSING_PUNCTUATION,
+    DOC_SUSPICIOUS_FOOTNOTES,
+    EMPTY_DOCS,
+    MISSING_ERRORS_DOC,
+    MISSING_PANICS_DOC,
+    MISSING_SAFETY_DOC,
+    NEEDLESS_DOCTEST_MAIN,
+    SUSPICIOUS_DOC_COMMENTS,
+    TEST_ATTR_IN_DOCTEST,
+    TOO_LONG_FIRST_DOC_PARAGRAPH,
+    UNNECESSARY_SAFETY_DOC,
+]);
+
 pub struct Documentation {
     valid_idents: FxHashSet<String>,
     check_private_items: bool,
@@ -718,29 +741,6 @@ impl Documentation {
     }
 }
 
-impl_lint_pass!(Documentation => [
-    DOC_LINK_CODE,
-    DOC_LINK_WITH_QUOTES,
-    DOC_BROKEN_LINK,
-    DOC_MARKDOWN,
-    DOC_NESTED_REFDEFS,
-    MISSING_SAFETY_DOC,
-    MISSING_ERRORS_DOC,
-    MISSING_PANICS_DOC,
-    NEEDLESS_DOCTEST_MAIN,
-    TEST_ATTR_IN_DOCTEST,
-    UNNECESSARY_SAFETY_DOC,
-    SUSPICIOUS_DOC_COMMENTS,
-    EMPTY_DOCS,
-    DOC_LAZY_CONTINUATION,
-    DOC_OVERINDENTED_LIST_ITEMS,
-    TOO_LONG_FIRST_DOC_PARAGRAPH,
-    DOC_INCLUDE_WITHOUT_CFG,
-    DOC_COMMENT_DOUBLE_SPACE_LINEBREAKS,
-    DOC_SUSPICIOUS_FOOTNOTES,
-    DOC_PARAGRAPHS_MISSING_PUNCTUATION,
-]);
-
 impl EarlyLintPass for Documentation {
     fn check_attributes(&mut self, cx: &EarlyContext<'_>, attrs: &[rustc_ast::Attribute]) {
         include_in_doc_without_cfg::check(cx, attrs);
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 3bb8c484ceec..5da76bc3095f 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -70,17 +70,13 @@ declare_clippy_lint! {
     "`mem::forget` usage on `Drop` types, likely to cause memory leaks"
 }
 
+declare_lint_pass!(DropForgetRef => [DROP_NON_DROP, FORGET_NON_DROP, MEM_FORGET]);
+
 const DROP_NON_DROP_SUMMARY: &str = "call to `std::mem::drop` with a value that does not implement `Drop`. \
                                  Dropping such a type only extends its contained lifetimes";
 const FORGET_NON_DROP_SUMMARY: &str = "call to `std::mem::forget` with a value that does not implement `Drop`. \
                                    Forgetting such a type is the same as dropping it";
 
-declare_lint_pass!(DropForgetRef => [
-    DROP_NON_DROP,
-    FORGET_NON_DROP,
-    MEM_FORGET,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Call(path, [arg]) = expr.kind
diff --git a/clippy_lints/src/duplicate_mod.rs b/clippy_lints/src/duplicate_mod.rs
index 759b7b6837bd..f3facac32107 100644
--- a/clippy_lints/src/duplicate_mod.rs
+++ b/clippy_lints/src/duplicate_mod.rs
@@ -46,6 +46,8 @@ declare_clippy_lint! {
     "file loaded as module multiple times"
 }
 
+impl_lint_pass!(DuplicateMod => [DUPLICATE_MOD]);
+
 struct Modules {
     local_path: PathBuf,
     spans: Vec<Span>,
@@ -59,8 +61,6 @@ pub struct DuplicateMod {
     modules: BTreeMap<PathBuf, Modules>,
 }
 
-impl_lint_pass!(DuplicateMod => [DUPLICATE_MOD]);
-
 impl EarlyLintPass for DuplicateMod {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
         if let ItemKind::Mod(_, _, ModKind::Loaded(_, Inline::No { .. }, mod_spans)) = &item.kind
diff --git a/clippy_lints/src/empty_drop.rs b/clippy_lints/src/empty_drop.rs
index 2b8221884344..1a10e962e875 100644
--- a/clippy_lints/src/empty_drop.rs
+++ b/clippy_lints/src/empty_drop.rs
@@ -31,6 +31,7 @@ declare_clippy_lint! {
     restriction,
     "empty `Drop` implementations"
 }
+
 declare_lint_pass!(EmptyDrop => [EMPTY_DROP]);
 
 impl LateLintPass<'_> for EmptyDrop {
diff --git a/clippy_lints/src/empty_line_after.rs b/clippy_lints/src/empty_line_after.rs
index 76e67b1154be..70ae8c0f07f5 100644
--- a/clippy_lints/src/empty_line_after.rs
+++ b/clippy_lints/src/empty_line_after.rs
@@ -12,41 +12,6 @@ use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::impl_lint_pass;
 use rustc_span::{BytePos, ExpnKind, Ident, InnerSpan, Span, SpanData, Symbol, kw, sym};
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for empty lines after outer attributes
-    ///
-    /// ### Why is this bad?
-    /// The attribute may have meant to be an inner attribute (`#![attr]`). If
-    /// it was meant to be an outer attribute (`#[attr]`) then the empty line
-    /// should be removed
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[allow(dead_code)]
-    ///
-    /// fn not_quite_good_code() {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// // Good (as inner attribute)
-    /// #![allow(dead_code)]
-    ///
-    /// fn this_is_fine() {}
-    ///
-    /// // or
-    ///
-    /// // Good (as outer attribute)
-    /// #[allow(dead_code)]
-    /// fn this_is_fine_too() {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EMPTY_LINE_AFTER_OUTER_ATTR,
-    suspicious,
-    "empty line after outer attribute"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for empty lines after doc comments.
@@ -88,6 +53,46 @@ declare_clippy_lint! {
     "empty line after doc comments"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for empty lines after outer attributes
+    ///
+    /// ### Why is this bad?
+    /// The attribute may have meant to be an inner attribute (`#![attr]`). If
+    /// it was meant to be an outer attribute (`#[attr]`) then the empty line
+    /// should be removed
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[allow(dead_code)]
+    ///
+    /// fn not_quite_good_code() {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// // Good (as inner attribute)
+    /// #![allow(dead_code)]
+    ///
+    /// fn this_is_fine() {}
+    ///
+    /// // or
+    ///
+    /// // Good (as outer attribute)
+    /// #[allow(dead_code)]
+    /// fn this_is_fine_too() {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub EMPTY_LINE_AFTER_OUTER_ATTR,
+    suspicious,
+    "empty line after outer attribute"
+}
+
+impl_lint_pass!(EmptyLineAfter => [
+    EMPTY_LINE_AFTER_DOC_COMMENTS,
+    EMPTY_LINE_AFTER_OUTER_ATTR,
+]);
+
 #[derive(Debug)]
 struct ItemInfo {
     kind: &'static str,
@@ -100,11 +105,6 @@ pub struct EmptyLineAfter {
     items: Vec<ItemInfo>,
 }
 
-impl_lint_pass!(EmptyLineAfter => [
-    EMPTY_LINE_AFTER_OUTER_ATTR,
-    EMPTY_LINE_AFTER_DOC_COMMENTS,
-]);
-
 impl EmptyLineAfter {
     pub fn new() -> Self {
         Self { items: Vec::new() }
diff --git a/clippy_lints/src/empty_with_brackets.rs b/clippy_lints/src/empty_with_brackets.rs
index 7e335d5c9809..53e6b7f95ae3 100644
--- a/clippy_lints/src/empty_with_brackets.rs
+++ b/clippy_lints/src/empty_with_brackets.rs
@@ -16,67 +16,72 @@ use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds structs without fields (a so-called "empty struct") that are declared with brackets.
+    /// Finds enum variants without fields that are declared with empty brackets.
     ///
     /// ### Why restrict this?
-    /// Empty brackets after a struct declaration can be omitted,
+    /// Empty brackets after a enum variant declaration are redundant and can be omitted,
     /// and it may be desirable to do so consistently for style.
     ///
-    /// However, removing the brackets also introduces a public constant named after the struct,
+    /// However, removing the brackets also introduces a public constant named after the variant,
     /// so this is not just a syntactic simplification but an API change, and adding them back
     /// is a *breaking* API change.
     ///
     /// ### Example
     /// ```no_run
-    /// struct Cookie {}
-    /// struct Biscuit();
+    /// enum MyEnum {
+    ///     HasData(u8),
+    ///     HasNoData(),       // redundant parentheses
+    ///     NoneHereEither {}, // redundant braces
+    /// }
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// struct Cookie;
-    /// struct Biscuit;
+    /// enum MyEnum {
+    ///     HasData(u8),
+    ///     HasNoData,
+    ///     NoneHereEither,
+    /// }
     /// ```
-    #[clippy::version = "1.62.0"]
-    pub EMPTY_STRUCTS_WITH_BRACKETS,
+    #[clippy::version = "1.77.0"]
+    pub EMPTY_ENUM_VARIANTS_WITH_BRACKETS,
     restriction,
-    "finds struct declarations with empty brackets"
+    "finds enum variants with empty brackets"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds enum variants without fields that are declared with empty brackets.
+    /// Finds structs without fields (a so-called "empty struct") that are declared with brackets.
     ///
     /// ### Why restrict this?
-    /// Empty brackets after a enum variant declaration are redundant and can be omitted,
+    /// Empty brackets after a struct declaration can be omitted,
     /// and it may be desirable to do so consistently for style.
     ///
-    /// However, removing the brackets also introduces a public constant named after the variant,
+    /// However, removing the brackets also introduces a public constant named after the struct,
     /// so this is not just a syntactic simplification but an API change, and adding them back
     /// is a *breaking* API change.
     ///
     /// ### Example
     /// ```no_run
-    /// enum MyEnum {
-    ///     HasData(u8),
-    ///     HasNoData(),       // redundant parentheses
-    ///     NoneHereEither {}, // redundant braces
-    /// }
+    /// struct Cookie {}
+    /// struct Biscuit();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// enum MyEnum {
-    ///     HasData(u8),
-    ///     HasNoData,
-    ///     NoneHereEither,
-    /// }
+    /// struct Cookie;
+    /// struct Biscuit;
     /// ```
-    #[clippy::version = "1.77.0"]
-    pub EMPTY_ENUM_VARIANTS_WITH_BRACKETS,
+    #[clippy::version = "1.62.0"]
+    pub EMPTY_STRUCTS_WITH_BRACKETS,
     restriction,
-    "finds enum variants with empty brackets"
+    "finds struct declarations with empty brackets"
 }
 
+impl_lint_pass!(EmptyWithBrackets => [
+    EMPTY_ENUM_VARIANTS_WITH_BRACKETS,
+    EMPTY_STRUCTS_WITH_BRACKETS,
+]);
+
 #[derive(Debug)]
 enum Usage {
     Unused { redundant_use_sites: Vec<Span> },
@@ -90,8 +95,6 @@ pub struct EmptyWithBrackets {
     empty_tuple_enum_variants: FxIndexMap<LocalDefId, Usage>,
 }
 
-impl_lint_pass!(EmptyWithBrackets => [EMPTY_STRUCTS_WITH_BRACKETS, EMPTY_ENUM_VARIANTS_WITH_BRACKETS]);
-
 impl LateLintPass<'_> for EmptyWithBrackets {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         // FIXME: handle `struct $name {}`
diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index 75db923b1c37..d76729047cdc 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -8,6 +8,24 @@ use rustc_session::declare_lint_pass;
 use rustc_span::Symbol;
 use std::fmt::Write;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of the `to_be_bytes` method and/or the function `from_be_bytes`.
+    ///
+    /// ### Why restrict this?
+    /// To ensure use of little-endian or the target’s endianness rather than big-endian.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let _x = 2i32.to_be_bytes();
+    /// let _y = 2i64.to_be_bytes();
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub BIG_ENDIAN_BYTES,
+    restriction,
+    "disallows usage of the `to_be_bytes` method"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the usage of the `to_ne_bytes` method and/or the function `from_ne_bytes`.
@@ -45,25 +63,11 @@ declare_clippy_lint! {
     "disallows usage of the `to_le_bytes` method"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the usage of the `to_be_bytes` method and/or the function `from_be_bytes`.
-    ///
-    /// ### Why restrict this?
-    /// To ensure use of little-endian or the target’s endianness rather than big-endian.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// let _x = 2i32.to_be_bytes();
-    /// let _y = 2i64.to_be_bytes();
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub BIG_ENDIAN_BYTES,
-    restriction,
-    "disallows usage of the `to_be_bytes` method"
-}
-
-declare_lint_pass!(EndianBytes => [HOST_ENDIAN_BYTES, LITTLE_ENDIAN_BYTES, BIG_ENDIAN_BYTES]);
+declare_lint_pass!(EndianBytes => [
+    BIG_ENDIAN_BYTES,
+    HOST_ENDIAN_BYTES,
+    LITTLE_ENDIAN_BYTES,
+]);
 
 const HOST_NAMES: [Symbol; 2] = [sym::from_ne_bytes, sym::to_ne_bytes];
 const LITTLE_NAMES: [Symbol; 2] = [sym::from_le_bytes, sym::to_le_bytes];
diff --git a/clippy_lints/src/error_impl_error.rs b/clippy_lints/src/error_impl_error.rs
index 3d8650f05168..c82761c1ad78 100644
--- a/clippy_lints/src/error_impl_error.rs
+++ b/clippy_lints/src/error_impl_error.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     restriction,
     "exported types named `Error` that implement `Error`"
 }
+
 declare_lint_pass!(ErrorImplError => [ERROR_IMPL_ERROR]);
 
 impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index fc224fa5f924..2e88d78ce909 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -50,6 +50,8 @@ declare_clippy_lint! {
     "using `Box<T>` where unnecessary"
 }
 
+impl_lint_pass!(BoxedLocal => [BOXED_LOCAL]);
+
 fn is_non_trait_box(ty: Ty<'_>) -> bool {
     ty.boxed_ty().is_some_and(|boxed| !boxed.is_trait())
 }
@@ -61,8 +63,6 @@ struct EscapeDelegate<'a, 'tcx> {
     too_large_for_stack: u64,
 }
 
-impl_lint_pass!(BoxedLocal => [BOXED_LOCAL]);
-
 impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
     fn check_fn(
         &mut self,
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 3e46c370fb70..b5781441bce6 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -66,7 +66,10 @@ declare_clippy_lint! {
     "redundant closures for method calls"
 }
 
-declare_lint_pass!(EtaReduction => [REDUNDANT_CLOSURE, REDUNDANT_CLOSURE_FOR_METHOD_CALLS]);
+declare_lint_pass!(EtaReduction => [
+    REDUNDANT_CLOSURE,
+    REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for EtaReduction {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 686dc5c3c4fc..65d0ff9b543f 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -9,6 +9,44 @@ use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for excessive use of
+    /// bools in function definitions.
+    ///
+    /// ### Why is this bad?
+    /// Calls to such functions
+    /// are confusing and error prone, because it's
+    /// hard to remember argument order and you have
+    /// no type system support to back you up. Using
+    /// two-variant enums instead of bools often makes
+    /// API easier to use.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// fn f(is_round: bool, is_hot: bool) { ... }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// enum Shape {
+    ///     Round,
+    ///     Spiky,
+    /// }
+    ///
+    /// enum Temperature {
+    ///     Hot,
+    ///     IceCold,
+    /// }
+    ///
+    /// fn f(shape: Shape, temperature: Temperature) { ... }
+    /// ```
+    #[clippy::version = "1.43.0"]
+    pub FN_PARAMS_EXCESSIVE_BOOLS,
+    pedantic,
+    "using too many bools in function parameters"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for excessive
@@ -50,43 +88,10 @@ declare_clippy_lint! {
     "using too many bools in a struct"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for excessive use of
-    /// bools in function definitions.
-    ///
-    /// ### Why is this bad?
-    /// Calls to such functions
-    /// are confusing and error prone, because it's
-    /// hard to remember argument order and you have
-    /// no type system support to back you up. Using
-    /// two-variant enums instead of bools often makes
-    /// API easier to use.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// fn f(is_round: bool, is_hot: bool) { ... }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// enum Shape {
-    ///     Round,
-    ///     Spiky,
-    /// }
-    ///
-    /// enum Temperature {
-    ///     Hot,
-    ///     IceCold,
-    /// }
-    ///
-    /// fn f(shape: Shape, temperature: Temperature) { ... }
-    /// ```
-    #[clippy::version = "1.43.0"]
-    pub FN_PARAMS_EXCESSIVE_BOOLS,
-    pedantic,
-    "using too many bools in function parameters"
-}
+impl_lint_pass!(ExcessiveBools => [
+    FN_PARAMS_EXCESSIVE_BOOLS,
+    STRUCT_EXCESSIVE_BOOLS,
+]);
 
 pub struct ExcessiveBools {
     max_struct_bools: u64,
@@ -102,8 +107,6 @@ impl ExcessiveBools {
     }
 }
 
-impl_lint_pass!(ExcessiveBools => [STRUCT_EXCESSIVE_BOOLS, FN_PARAMS_EXCESSIVE_BOOLS]);
-
 fn has_n_bools<'tcx>(iter: impl Iterator<Item = &'tcx Ty<'tcx>>, mut count: u64) -> bool {
     iter.filter(|ty| is_bool(ty)).any(|_| {
         let (x, overflow) = count.overflowing_sub(1);
diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index 5368701c3041..58d00933a785 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -61,6 +61,7 @@ declare_clippy_lint! {
     complexity,
     "checks for blocks nested beyond a certain threshold"
 }
+
 impl_lint_pass!(ExcessiveNesting => [EXCESSIVE_NESTING]);
 
 pub struct ExcessiveNesting {
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index c59ffa14a5fe..a85025a48e5a 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -39,6 +39,8 @@ declare_clippy_lint! {
     "using the `write!()` family of functions instead of the `print!()` family of functions, when using the latter would work"
 }
 
+impl_lint_pass!(ExplicitWrite => [EXPLICIT_WRITE]);
+
 pub struct ExplicitWrite {
     format_args: FormatArgsStorage,
 }
@@ -49,8 +51,6 @@ impl ExplicitWrite {
     }
 }
 
-impl_lint_pass!(ExplicitWrite => [EXPLICIT_WRITE]);
-
 impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // match call to unwrap
diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index fb98cb30ae90..93a6dc59993a 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -40,6 +40,8 @@ declare_clippy_lint! {
     "unused type parameters in function definitions"
 }
 
+impl_lint_pass!(ExtraUnusedTypeParameters => [EXTRA_UNUSED_TYPE_PARAMETERS]);
+
 pub struct ExtraUnusedTypeParameters {
     avoid_breaking_exported_api: bool,
 }
@@ -52,8 +54,6 @@ impl ExtraUnusedTypeParameters {
     }
 }
 
-impl_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> {
diff --git a/clippy_lints/src/field_scoped_visibility_modifiers.rs b/clippy_lints/src/field_scoped_visibility_modifiers.rs
index dfb0b4f103c5..4b736c68cb86 100644
--- a/clippy_lints/src/field_scoped_visibility_modifiers.rs
+++ b/clippy_lints/src/field_scoped_visibility_modifiers.rs
@@ -47,7 +47,9 @@ declare_clippy_lint! {
     "checks for usage of a scoped visibility modifier, like `pub(crate)`, on fields"
 }
 
-declare_lint_pass!(FieldScopedVisibilityModifiers => [FIELD_SCOPED_VISIBILITY_MODIFIERS]);
+declare_lint_pass!(FieldScopedVisibilityModifiers => [
+    FIELD_SCOPED_VISIBILITY_MODIFIERS,
+]);
 
 impl EarlyLintPass for FieldScopedVisibilityModifiers {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 6178addfff12..c6ae2cfc2545 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -61,14 +61,12 @@ declare_clippy_lint! {
     "lossy whole number float literals"
 }
 
+impl_lint_pass!(FloatLiteral => [EXCESSIVE_PRECISION, LOSSY_FLOAT_LITERAL]);
+
 pub struct FloatLiteral {
     const_literal_digits_threshold: usize,
 }
 
-impl_lint_pass!(FloatLiteral => [
-    EXCESSIVE_PRECISION, LOSSY_FLOAT_LITERAL
-]);
-
 impl FloatLiteral {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/floating_point_arithmetic/mod.rs b/clippy_lints/src/floating_point_arithmetic/mod.rs
index edc638c96bbf..0833761b32dc 100644
--- a/clippy_lints/src/floating_point_arithmetic/mod.rs
+++ b/clippy_lints/src/floating_point_arithmetic/mod.rs
@@ -103,10 +103,7 @@ declare_clippy_lint! {
     "usage of sub-optimal floating point operations"
 }
 
-declare_lint_pass!(FloatingPointArithmetic => [
-    IMPRECISE_FLOPS,
-    SUBOPTIMAL_FLOPS
-]);
+declare_lint_pass!(FloatingPointArithmetic => [IMPRECISE_FLOPS, SUBOPTIMAL_FLOPS]);
 
 impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 098bf4ba42f9..486fdb8a2bb8 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -39,6 +39,8 @@ declare_clippy_lint! {
     "useless use of `format!`"
 }
 
+impl_lint_pass!(UselessFormat => [USELESS_FORMAT]);
+
 pub struct UselessFormat {
     format_args: FormatArgsStorage,
 }
@@ -49,8 +51,6 @@ impl UselessFormat {
     }
 }
 
-impl_lint_pass!(UselessFormat => [USELESS_FORMAT]);
-
 impl<'tcx> LateLintPass<'tcx> for UselessFormat {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let Some(macro_call) = root_macro_call_first_node(cx, expr)
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 3eb358917a0e..779655a81873 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -59,32 +59,30 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `Debug` formatting (`{:?}`) applied to an `OsStr` or `Path`.
+    /// Detects [pointer format] as well as `Debug` formatting of raw pointers or function pointers
+    /// or any types that have a derived `Debug` impl that recursively contains them.
     ///
-    /// ### Why is this bad?
-    /// Rust doesn't guarantee what `Debug` formatting looks like, and it could
-    /// change in the future. `OsStr`s and `Path`s can be `Display` formatted
-    /// using their `display` methods.
+    /// ### Why restrict this?
+    /// The addresses are only useful in very specific contexts, and certain projects may want to keep addresses of
+    /// certain data structures or functions from prying hacker eyes as an additional line of security.
     ///
-    /// Furthermore, with `Debug` formatting, certain characters are escaped.
-    /// Thus, a `Debug` formatted `Path` is less likely to be clickable.
+    /// ### Known problems
+    /// The lint currently only looks through derived `Debug` implementations. Checking whether a manual
+    /// implementation prints an address is left as an exercise to the next lint implementer.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::path::Path;
-    /// let path = Path::new("...");
-    /// println!("The path is {:?}", path);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # use std::path::Path;
-    /// let path = Path::new("…");
-    /// println!("The path is {}", path.display());
+    /// let foo = &0_u32;
+    /// fn bar() {}
+    /// println!("{:p}", foo);
+    /// let _ = format!("{:?}", &(bar as fn()));
     /// ```
-    #[clippy::version = "1.87.0"]
-    pub UNNECESSARY_DEBUG_FORMATTING,
-    pedantic,
-    "`Debug` formatting applied to an `OsStr` or `Path` when `.display()` is available"
+    ///
+    /// [pointer format]: https://doc.rust-lang.org/std/fmt/index.html#formatting-traits
+    #[clippy::version = "1.89.0"]
+    pub POINTER_FORMAT,
+    restriction,
+    "formatting a pointer"
 }
 
 declare_clippy_lint! {
@@ -172,61 +170,32 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detects [formatting parameters] that have no effect on the output of
-    /// `format!()`, `println!()` or similar macros.
+    /// Checks for `Debug` formatting (`{:?}`) applied to an `OsStr` or `Path`.
     ///
     /// ### Why is this bad?
-    /// Shorter format specifiers are easier to read, it may also indicate that
-    /// an expected formatting operation such as adding padding isn't happening.
+    /// Rust doesn't guarantee what `Debug` formatting looks like, and it could
+    /// change in the future. `OsStr`s and `Path`s can be `Display` formatted
+    /// using their `display` methods.
+    ///
+    /// Furthermore, with `Debug` formatting, certain characters are escaped.
+    /// Thus, a `Debug` formatted `Path` is less likely to be clickable.
     ///
     /// ### Example
     /// ```no_run
-    /// println!("{:.}", 1.0);
-    ///
-    /// println!("not padded: {:5}", format_args!("..."));
+    /// # use std::path::Path;
+    /// let path = Path::new("...");
+    /// println!("The path is {:?}", path);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// println!("{}", 1.0);
-    ///
-    /// println!("not padded: {}", format_args!("..."));
-    /// // OR
-    /// println!("padded: {:5}", format!("..."));
-    /// ```
-    ///
-    /// [formatting parameters]: https://doc.rust-lang.org/std/fmt/index.html#formatting-parameters
-    #[clippy::version = "1.66.0"]
-    pub UNUSED_FORMAT_SPECS,
-    complexity,
-    "use of a format specifier that has no effect"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects [pointer format] as well as `Debug` formatting of raw pointers or function pointers
-    /// or any types that have a derived `Debug` impl that recursively contains them.
-    ///
-    /// ### Why restrict this?
-    /// The addresses are only useful in very specific contexts, and certain projects may want to keep addresses of
-    /// certain data structures or functions from prying hacker eyes as an additional line of security.
-    ///
-    /// ### Known problems
-    /// The lint currently only looks through derived `Debug` implementations. Checking whether a manual
-    /// implementation prints an address is left as an exercise to the next lint implementer.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let foo = &0_u32;
-    /// fn bar() {}
-    /// println!("{:p}", foo);
-    /// let _ = format!("{:?}", &(bar as fn()));
+    /// # use std::path::Path;
+    /// let path = Path::new("…");
+    /// println!("The path is {}", path.display());
     /// ```
-    ///
-    /// [pointer format]: https://doc.rust-lang.org/std/fmt/index.html#formatting-traits
-    #[clippy::version = "1.89.0"]
-    pub POINTER_FORMAT,
-    restriction,
-    "formatting a pointer"
+    #[clippy::version = "1.87.0"]
+    pub UNNECESSARY_DEBUG_FORMATTING,
+    pedantic,
+    "`Debug` formatting applied to an `OsStr` or `Path` when `.display()` is available"
 }
 
 declare_clippy_lint! {
@@ -258,14 +227,45 @@ declare_clippy_lint! {
     "unnecessary trailing comma before closing parenthesis"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects [formatting parameters] that have no effect on the output of
+    /// `format!()`, `println!()` or similar macros.
+    ///
+    /// ### Why is this bad?
+    /// Shorter format specifiers are easier to read, it may also indicate that
+    /// an expected formatting operation such as adding padding isn't happening.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// println!("{:.}", 1.0);
+    ///
+    /// println!("not padded: {:5}", format_args!("..."));
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// println!("{}", 1.0);
+    ///
+    /// println!("not padded: {}", format_args!("..."));
+    /// // OR
+    /// println!("padded: {:5}", format!("..."));
+    /// ```
+    ///
+    /// [formatting parameters]: https://doc.rust-lang.org/std/fmt/index.html#formatting-parameters
+    #[clippy::version = "1.66.0"]
+    pub UNUSED_FORMAT_SPECS,
+    complexity,
+    "use of a format specifier that has no effect"
+}
+
 impl_lint_pass!(FormatArgs<'_> => [
     FORMAT_IN_FORMAT_ARGS,
+    POINTER_FORMAT,
     TO_STRING_IN_FORMAT_ARGS,
     UNINLINED_FORMAT_ARGS,
     UNNECESSARY_DEBUG_FORMATTING,
-    UNUSED_FORMAT_SPECS,
-    POINTER_FORMAT,
     UNNECESSARY_TRAILING_COMMA,
+    UNUSED_FORMAT_SPECS,
 ]);
 
 #[expect(clippy::struct_field_names)]
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index 903d43e56c4b..4d0a324a2a39 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -10,45 +10,6 @@ use rustc_session::impl_lint_pass;
 use rustc_span::Symbol;
 use rustc_span::symbol::kw;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for format trait implementations (e.g. `Display`) with a recursive call to itself
-    /// which uses `self` as a parameter.
-    /// This is typically done indirectly with the `write!` macro or with `to_string()`.
-    ///
-    /// ### Why is this bad?
-    /// This will lead to infinite recursion and a stack overflow.
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// use std::fmt;
-    ///
-    /// struct Structure(i32);
-    /// impl fmt::Display for Structure {
-    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    ///         write!(f, "{}", self.to_string())
-    ///     }
-    /// }
-    ///
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::fmt;
-    ///
-    /// struct Structure(i32);
-    /// impl fmt::Display for Structure {
-    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    ///         write!(f, "{}", self.0)
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.48.0"]
-    pub RECURSIVE_FORMAT_IMPL,
-    correctness,
-    "Format trait method called while implementing the same Format trait"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `println`, `print`, `eprintln` or `eprint` in an
@@ -90,6 +51,47 @@ declare_clippy_lint! {
     "use of a print macro in a formatting trait impl"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for format trait implementations (e.g. `Display`) with a recursive call to itself
+    /// which uses `self` as a parameter.
+    /// This is typically done indirectly with the `write!` macro or with `to_string()`.
+    ///
+    /// ### Why is this bad?
+    /// This will lead to infinite recursion and a stack overflow.
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// use std::fmt;
+    ///
+    /// struct Structure(i32);
+    /// impl fmt::Display for Structure {
+    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    ///         write!(f, "{}", self.to_string())
+    ///     }
+    /// }
+    ///
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// use std::fmt;
+    ///
+    /// struct Structure(i32);
+    /// impl fmt::Display for Structure {
+    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    ///         write!(f, "{}", self.0)
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub RECURSIVE_FORMAT_IMPL,
+    correctness,
+    "Format trait method called while implementing the same Format trait"
+}
+
+impl_lint_pass!(FormatImpl => [PRINT_IN_FORMAT_IMPL, RECURSIVE_FORMAT_IMPL]);
+
 #[derive(Clone, Copy)]
 struct FormatTraitNames {
     /// e.g. `sym::Display`
@@ -113,8 +115,6 @@ impl FormatImpl {
     }
 }
 
-impl_lint_pass!(FormatImpl => [RECURSIVE_FORMAT_IMPL, PRINT_IN_FORMAT_IMPL]);
-
 impl<'tcx> LateLintPass<'tcx> for FormatImpl {
     fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
         self.format_trait_impl = is_format_trait_impl(cx, impl_item);
diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index fea55f91bce7..c51a1b016285 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     pedantic,
     "`format!(..)` appended to existing `String`"
 }
+
 impl_lint_pass!(FormatPushString => [FORMAT_PUSH_STRING]);
 
 pub(crate) struct FormatPushString {
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 7a64d3135fa5..87e290cf0357 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -8,50 +8,67 @@ use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of the non-existent `=*`, `=!` and `=-`
-    /// operators.
+    /// Checks for possible missing comma in an array. It lints if
+    /// an array element is a binary operator expression and it lies on two lines.
     ///
     /// ### Why is this bad?
-    /// This is either a typo of `*=`, `!=` or `-=` or
-    /// confusing.
+    /// This could lead to unexpected results.
     ///
     /// ### Example
     /// ```rust,ignore
-    /// a =- 42; // confusing, should it be `a -= 42` or `a = -42`?
+    /// let a = &[
+    ///     -1, -2, -3 // <= no comma here
+    ///     -4, -5, -6
+    /// ];
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub SUSPICIOUS_ASSIGNMENT_FORMATTING,
-    suspicious,
-    "suspicious formatting of `*=`, `-=` or `!=`"
+    pub POSSIBLE_MISSING_COMMA,
+    correctness,
+    "possible missing comma in array"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks the formatting of a unary operator on the right hand side
-    /// of a binary operator. It lints if there is no space between the binary and unary operators,
-    /// but there is a space between the unary and its operand.
+    /// Checks for an `if` expression followed by either a block or another `if` that
+    /// looks like it should have an `else` between them.
     ///
     /// ### Why is this bad?
-    /// This is either a typo in the binary operator or confusing.
+    /// This is probably some refactoring remnant, even if the code is correct, it
+    /// might look confusing.
     ///
     /// ### Example
-    /// ```no_run
-    /// # let foo = true;
-    /// # let bar = false;
-    /// // &&! looks like a different operator
-    /// if foo &&! bar {}
+    /// ```rust,ignore
+    /// if foo {
+    /// } { // looks like an `else` is missing here
+    /// }
+    ///
+    /// if foo {
+    /// } if bar { // looks like an `else` is missing here
+    /// }
     /// ```
+    #[clippy::version = "1.91.0"]
+    pub POSSIBLE_MISSING_ELSE,
+    suspicious,
+    "possibly missing `else`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of the non-existent `=*`, `=!` and `=-`
+    /// operators.
     ///
-    /// Use instead:
-    /// ```no_run
-    /// # let foo = true;
-    /// # let bar = false;
-    /// if foo && !bar {}
+    /// ### Why is this bad?
+    /// This is either a typo of `*=`, `!=` or `-=` or
+    /// confusing.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// a =- 42; // confusing, should it be `a -= 42` or `a = -42`?
     /// ```
-    #[clippy::version = "1.40.0"]
-    pub SUSPICIOUS_UNARY_OP_FORMATTING,
+    #[clippy::version = "pre 1.29.0"]
+    pub SUSPICIOUS_ASSIGNMENT_FORMATTING,
     suspicious,
-    "suspicious formatting of unary `-` or `!` on the RHS of a BinOp"
+    "suspicious formatting of `*=`, `-=` or `!=`"
 }
 
 declare_clippy_lint! {
@@ -93,56 +110,39 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for an `if` expression followed by either a block or another `if` that
-    /// looks like it should have an `else` between them.
+    /// Checks the formatting of a unary operator on the right hand side
+    /// of a binary operator. It lints if there is no space between the binary and unary operators,
+    /// but there is a space between the unary and its operand.
     ///
     /// ### Why is this bad?
-    /// This is probably some refactoring remnant, even if the code is correct, it
-    /// might look confusing.
+    /// This is either a typo in the binary operator or confusing.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// if foo {
-    /// } { // looks like an `else` is missing here
-    /// }
-    ///
-    /// if foo {
-    /// } if bar { // looks like an `else` is missing here
-    /// }
+    /// ```no_run
+    /// # let foo = true;
+    /// # let bar = false;
+    /// // &&! looks like a different operator
+    /// if foo &&! bar {}
     /// ```
-    #[clippy::version = "1.91.0"]
-    pub POSSIBLE_MISSING_ELSE,
-    suspicious,
-    "possibly missing `else`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for possible missing comma in an array. It lints if
-    /// an array element is a binary operator expression and it lies on two lines.
-    ///
-    /// ### Why is this bad?
-    /// This could lead to unexpected results.
     ///
-    /// ### Example
-    /// ```rust,ignore
-    /// let a = &[
-    ///     -1, -2, -3 // <= no comma here
-    ///     -4, -5, -6
-    /// ];
+    /// Use instead:
+    /// ```no_run
+    /// # let foo = true;
+    /// # let bar = false;
+    /// if foo && !bar {}
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub POSSIBLE_MISSING_COMMA,
-    correctness,
-    "possible missing comma in array"
+    #[clippy::version = "1.40.0"]
+    pub SUSPICIOUS_UNARY_OP_FORMATTING,
+    suspicious,
+    "suspicious formatting of unary `-` or `!` on the RHS of a BinOp"
 }
 
 declare_lint_pass!(Formatting => [
+    POSSIBLE_MISSING_COMMA,
+    POSSIBLE_MISSING_ELSE,
     SUSPICIOUS_ASSIGNMENT_FORMATTING,
-    SUSPICIOUS_UNARY_OP_FORMATTING,
     SUSPICIOUS_ELSE_FORMATTING,
-    POSSIBLE_MISSING_ELSE,
-    POSSIBLE_MISSING_COMMA
+    SUSPICIOUS_UNARY_OP_FORMATTING,
 ]);
 
 impl EarlyLintPass for Formatting {
diff --git a/clippy_lints/src/four_forward_slashes.rs b/clippy_lints/src/four_forward_slashes.rs
index 5a0cee40a155..57c1dd2eb72b 100644
--- a/clippy_lints/src/four_forward_slashes.rs
+++ b/clippy_lints/src/four_forward_slashes.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     suspicious,
     "comments with 4 forward slashes (`////`) likely intended to be doc comments (`///`)"
 }
+
 declare_lint_pass!(FourForwardSlashes => [FOUR_FORWARD_SLASHES]);
 
 impl<'tcx> LateLintPass<'tcx> for FourForwardSlashes {
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index ed55f90848f8..841d561b371c 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -52,6 +52,8 @@ declare_clippy_lint! {
     "Warns on implementations of `Into<..>` to use `From<..>`"
 }
 
+impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
+
 pub struct FromOverInto {
     msrv: Msrv,
 }
@@ -62,8 +64,6 @@ impl FromOverInto {
     }
 }
 
-impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
-
 impl<'tcx> LateLintPass<'tcx> for FromOverInto {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Impl(Impl {
diff --git a/clippy_lints/src/from_raw_with_void_ptr.rs b/clippy_lints/src/from_raw_with_void_ptr.rs
index 0e6eeb75ec57..5c6d6607a0aa 100644
--- a/clippy_lints/src/from_raw_with_void_ptr.rs
+++ b/clippy_lints/src/from_raw_with_void_ptr.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     suspicious,
     "creating a `Box` from a void raw pointer"
 }
+
 declare_lint_pass!(FromRawWithVoidPtr => [FROM_RAW_WITH_VOID_PTR]);
 
 impl LateLintPass<'_> for FromRawWithVoidPtr {
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 9a7427ea1447..7c5fd760a7da 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -21,6 +21,30 @@ use rustc_session::{declare_lint_pass, impl_lint_pass};
 use rustc_span::Span;
 use rustc_span::def_id::{DefIdSet, LocalDefId};
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for a `#[must_use]` attribute without
+    /// further information on functions and methods that return a type already
+    /// marked as `#[must_use]`.
+    ///
+    /// ### Why is this bad?
+    /// The attribute isn't needed. Not using the result
+    /// will already be reported. Alternatively, one can add some text to the
+    /// attribute to improve the lint message.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// #[must_use]
+    /// fn double_must_use() -> Result<(), ()> {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    #[clippy::version = "1.40.0"]
+    pub DOUBLE_MUST_USE,
+    style,
+    "`#[must_use]` attribute on a `#[must_use]`-returning function / method"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for function arguments having the similar names
@@ -46,48 +70,122 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for functions with too many parameters.
+    /// Lints when `impl Trait` is being used in a function's parameters.
     ///
-    /// ### Why is this bad?
-    /// Functions with lots of parameters are considered bad
-    /// style and reduce readability (“what does the 5th parameter mean?”). Consider
-    /// grouping some parameters into a new type.
+    /// ### Why restrict this?
+    /// Turbofish syntax (`::<>`) cannot be used to specify the type of an `impl Trait` parameter,
+    /// making `impl Trait` less powerful. Readability may also be a factor.
     ///
     /// ### Example
     /// ```no_run
-    /// # struct Color;
-    /// fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {
-    ///     // ..
+    /// trait MyTrait {}
+    /// fn foo(a: impl MyTrait) {
+    /// 	// [...]
     /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TOO_MANY_ARGUMENTS,
-    complexity,
-    "functions with too many arguments"
+    /// Use instead:
+    /// ```no_run
+    /// trait MyTrait {}
+    /// fn foo<T: MyTrait>(a: T) {
+    /// 	// [...]
+    /// }
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub IMPL_TRAIT_IN_PARAMS,
+    restriction,
+    "`impl Trait` is used in the function's parameters"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for functions with a large amount of lines.
+    /// Checks for getter methods that return a field that doesn't correspond
+    /// to the name of the method, when there is a field's whose name matches that of the method.
     ///
     /// ### Why is this bad?
-    /// Functions with a lot of lines are harder to understand
-    /// due to having to look at a larger amount of code to understand what the
-    /// function is doing. Consider splitting the body of the function into
-    /// multiple functions.
+    /// It is most likely that such a method is a bug caused by a typo or by copy-pasting.
     ///
     /// ### Example
+
     /// ```no_run
-    /// fn im_too_long() {
-    ///     println!("");
-    ///     // ... 100 more LoC
-    ///     println!("");
+    /// struct A {
+    ///     a: String,
+    ///     b: String,
+    /// }
+    ///
+    /// impl A {
+    ///     fn a(&self) -> &str{
+    ///         &self.b
+    ///     }
     /// }
+
     /// ```
-    #[clippy::version = "1.34.0"]
-    pub TOO_MANY_LINES,
+    /// Use instead:
+    /// ```no_run
+    /// struct A {
+    ///     a: String,
+    ///     b: String,
+    /// }
+    ///
+    /// impl A {
+    ///     fn a(&self) -> &str{
+    ///         &self.a
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.67.0"]
+    pub MISNAMED_GETTERS,
+    suspicious,
+    "getter method returning the wrong field"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for public functions that have no
+    /// `#[must_use]` attribute, but return something not already marked
+    /// must-use, have no mutable arg and mutate no statics.
+    ///
+    /// ### Why is this bad?
+    /// Not bad at all, this lint just shows places where
+    /// you could add the attribute.
+    ///
+    /// ### Known problems
+    /// The lint only checks the arguments for mutable
+    /// types without looking if they are actually changed. On the other hand,
+    /// it also ignores a broad range of potentially interesting side effects,
+    /// because we cannot decide whether the programmer intends the function to
+    /// be called for the side effect or the result. Expect many false
+    /// positives. At least we don't lint if the result type is unit or already
+    /// `#[must_use]`.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// // this could be annotated with `#[must_use]`.
+    /// pub fn id<T>(t: T) -> T { t }
+    /// ```
+    #[clippy::version = "1.40.0"]
+    pub MUST_USE_CANDIDATE,
     pedantic,
-    "functions with too many lines"
+    "function or method that could take a `#[must_use]` attribute"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for a `#[must_use]` attribute on
+    /// unit-returning functions and methods.
+    ///
+    /// ### Why is this bad?
+    /// Unit values are useless. The attribute is likely
+    /// a remnant of a refactoring that removed the return type.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// #[must_use]
+    /// fn useless() { }
+    /// ```
+    #[clippy::version = "1.40.0"]
+    pub MUST_USE_UNIT,
+    style,
+    "`#[must_use]` attribute on a unit-returning function / method"
 }
 
 declare_clippy_lint! {
@@ -152,126 +250,83 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for a `#[must_use]` attribute on
-    /// unit-returning functions and methods.
-    ///
-    /// ### Why is this bad?
-    /// Unit values are useless. The attribute is likely
-    /// a remnant of a refactoring that removed the return type.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// #[must_use]
-    /// fn useless() { }
-    /// ```
-    #[clippy::version = "1.40.0"]
-    pub MUST_USE_UNIT,
-    style,
-    "`#[must_use]` attribute on a unit-returning function / method"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for a `#[must_use]` attribute without
-    /// further information on functions and methods that return a type already
-    /// marked as `#[must_use]`.
+    /// Warns when a function signature uses `&Option<T>` instead of `Option<&T>`.
     ///
     /// ### Why is this bad?
-    /// The attribute isn't needed. Not using the result
-    /// will already be reported. Alternatively, one can add some text to the
-    /// attribute to improve the lint message.
+    /// More flexibility, better memory optimization, and more idiomatic Rust code.
     ///
-    /// ### Examples
-    /// ```no_run
-    /// #[must_use]
-    /// fn double_must_use() -> Result<(), ()> {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    #[clippy::version = "1.40.0"]
-    pub DOUBLE_MUST_USE,
-    style,
-    "`#[must_use]` attribute on a `#[must_use]`-returning function / method"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for public functions that have no
-    /// `#[must_use]` attribute, but return something not already marked
-    /// must-use, have no mutable arg and mutate no statics.
+    /// `&Option<T>` in a function signature breaks encapsulation because the caller must own T
+    /// and move it into an Option to call with it. When returned, the owner must internally store
+    /// it as `Option<T>` in order to return it.
+    /// At a lower level, `&Option<T>` points to memory with the `presence` bit flag plus the `T` value,
+    /// whereas `Option<&T>` is usually [optimized](https://doc.rust-lang.org/1.81.0/std/option/index.html#representation)
+    /// to a single pointer, so it may be more optimal.
     ///
-    /// ### Why is this bad?
-    /// Not bad at all, this lint just shows places where
-    /// you could add the attribute.
+    /// See this [YouTube video](https://www.youtube.com/watch?v=6c7pZYP_iIE) by
+    /// Logan Smith for an in-depth explanation of why this is important.
     ///
     /// ### Known problems
-    /// The lint only checks the arguments for mutable
-    /// types without looking if they are actually changed. On the other hand,
-    /// it also ignores a broad range of potentially interesting side effects,
-    /// because we cannot decide whether the programmer intends the function to
-    /// be called for the side effect or the result. Expect many false
-    /// positives. At least we don't lint if the result type is unit or already
-    /// `#[must_use]`.
+    /// This lint recommends changing the function signatures, but it cannot
+    /// automatically change the function calls or the function implementations.
     ///
-    /// ### Examples
+    /// ### Example
     /// ```no_run
-    /// // this could be annotated with `#[must_use]`.
-    /// pub fn id<T>(t: T) -> T { t }
+    /// // caller uses  foo(&opt)
+    /// fn foo(a: &Option<String>) {}
+    /// # struct Unit {}
+    /// # impl Unit {
+    /// fn bar(&self) -> &Option<String> { &None }
+    /// # }
     /// ```
-    #[clippy::version = "1.40.0"]
-    pub MUST_USE_CANDIDATE,
+    /// Use instead:
+    /// ```no_run
+    /// // caller should use  `foo1(opt.as_ref())`
+    /// fn foo1(a: Option<&String>) {}
+    /// // better yet, use string slice  `foo2(opt.as_deref())`
+    /// fn foo2(a: Option<&str>) {}
+    /// # struct Unit {}
+    /// # impl Unit {
+    /// fn bar(&self) -> Option<&String> { None }
+    /// # }
+    /// ```
+    #[clippy::version = "1.83.0"]
+    pub REF_OPTION,
     pedantic,
-    "function or method that could take a `#[must_use]` attribute"
+    "function signature uses `&Option<T>` instead of `Option<&T>`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for public functions that return a `Result`
-    /// with an `Err` type of `()`. It suggests using a custom type that
-    /// implements `std::error::Error`.
+    /// Lints when the name of function parameters from trait impl is
+    /// different than its default implementation.
     ///
-    /// ### Why is this bad?
-    /// Unit does not implement `Error` and carries no
-    /// further information about what went wrong.
+    /// ### Why restrict this?
+    /// Using the default name for parameters of a trait method is more consistent.
     ///
-    /// ### Known problems
-    /// Of course, this lint assumes that `Result` is used
-    /// for a fallible operation (which is after all the intended use). However
-    /// code may opt to (mis)use it as a basic two-variant-enum. In that case,
-    /// the suggestion is misguided, and the code should use a custom enum
-    /// instead.
+    /// ### Example
+    /// ```rust
+    /// struct A(u32);
     ///
-    /// ### Examples
-    /// ```no_run
-    /// pub fn read_u8() -> Result<u8, ()> { Err(()) }
+    /// impl PartialEq for A {
+    ///     fn eq(&self, b: &Self) -> bool {
+    ///         self.0 == b.0
+    ///     }
+    /// }
     /// ```
-    /// should become
-    /// ```rust,should_panic
-    /// use std::fmt;
-    ///
-    /// #[derive(Debug)]
-    /// pub struct EndOfStream;
+    /// Use instead:
+    /// ```rust
+    /// struct A(u32);
     ///
-    /// impl fmt::Display for EndOfStream {
-    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    ///         write!(f, "End of Stream")
+    /// impl PartialEq for A {
+    ///     fn eq(&self, other: &Self) -> bool {
+    ///         self.0 == other.0
     ///     }
     /// }
-    ///
-    /// impl std::error::Error for EndOfStream { }
-    ///
-    /// pub fn read_u8() -> Result<u8, EndOfStream> { Err(EndOfStream) }
-    ///# fn main() {
-    ///#     read_u8().unwrap();
-    ///# }
     /// ```
-    ///
-    /// Note that there are crates that simplify creating the error type, e.g.
-    /// [`thiserror`](https://docs.rs/thiserror).
-    #[clippy::version = "1.49.0"]
-    pub RESULT_UNIT_ERR,
-    style,
-    "public function returning `Result` with an `Err` type of `()`"
+    #[clippy::version = "1.80.0"]
+    pub RENAMED_FUNCTION_PARAMS,
+    restriction,
+    "renamed function parameters in trait implementation"
 }
 
 declare_clippy_lint! {
@@ -324,157 +379,117 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for getter methods that return a field that doesn't correspond
-    /// to the name of the method, when there is a field's whose name matches that of the method.
+    /// Checks for public functions that return a `Result`
+    /// with an `Err` type of `()`. It suggests using a custom type that
+    /// implements `std::error::Error`.
     ///
     /// ### Why is this bad?
-    /// It is most likely that such a method is a bug caused by a typo or by copy-pasting.
+    /// Unit does not implement `Error` and carries no
+    /// further information about what went wrong.
     ///
-    /// ### Example
-
-    /// ```no_run
-    /// struct A {
-    ///     a: String,
-    ///     b: String,
-    /// }
+    /// ### Known problems
+    /// Of course, this lint assumes that `Result` is used
+    /// for a fallible operation (which is after all the intended use). However
+    /// code may opt to (mis)use it as a basic two-variant-enum. In that case,
+    /// the suggestion is misguided, and the code should use a custom enum
+    /// instead.
     ///
-    /// impl A {
-    ///     fn a(&self) -> &str{
-    ///         &self.b
-    ///     }
-    /// }
-
-    /// ```
-    /// Use instead:
+    /// ### Examples
     /// ```no_run
-    /// struct A {
-    ///     a: String,
-    ///     b: String,
-    /// }
+    /// pub fn read_u8() -> Result<u8, ()> { Err(()) }
+    /// ```
+    /// should become
+    /// ```rust,should_panic
+    /// use std::fmt;
     ///
-    /// impl A {
-    ///     fn a(&self) -> &str{
-    ///         &self.a
+    /// #[derive(Debug)]
+    /// pub struct EndOfStream;
+    ///
+    /// impl fmt::Display for EndOfStream {
+    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         write!(f, "End of Stream")
     ///     }
     /// }
-    /// ```
-    #[clippy::version = "1.67.0"]
-    pub MISNAMED_GETTERS,
-    suspicious,
-    "getter method returning the wrong field"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lints when `impl Trait` is being used in a function's parameters.
     ///
-    /// ### Why restrict this?
-    /// Turbofish syntax (`::<>`) cannot be used to specify the type of an `impl Trait` parameter,
-    /// making `impl Trait` less powerful. Readability may also be a factor.
+    /// impl std::error::Error for EndOfStream { }
     ///
-    /// ### Example
-    /// ```no_run
-    /// trait MyTrait {}
-    /// fn foo(a: impl MyTrait) {
-    /// 	// [...]
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// trait MyTrait {}
-    /// fn foo<T: MyTrait>(a: T) {
-    /// 	// [...]
-    /// }
+    /// pub fn read_u8() -> Result<u8, EndOfStream> { Err(EndOfStream) }
+    ///# fn main() {
+    ///#     read_u8().unwrap();
+    ///# }
     /// ```
-    #[clippy::version = "1.69.0"]
-    pub IMPL_TRAIT_IN_PARAMS,
-    restriction,
-    "`impl Trait` is used in the function's parameters"
+    ///
+    /// Note that there are crates that simplify creating the error type, e.g.
+    /// [`thiserror`](https://docs.rs/thiserror).
+    #[clippy::version = "1.49.0"]
+    pub RESULT_UNIT_ERR,
+    style,
+    "public function returning `Result` with an `Err` type of `()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Lints when the name of function parameters from trait impl is
-    /// different than its default implementation.
+    /// Checks for functions with too many parameters.
     ///
-    /// ### Why restrict this?
-    /// Using the default name for parameters of a trait method is more consistent.
+    /// ### Why is this bad?
+    /// Functions with lots of parameters are considered bad
+    /// style and reduce readability (“what does the 5th parameter mean?”). Consider
+    /// grouping some parameters into a new type.
     ///
     /// ### Example
-    /// ```rust
-    /// struct A(u32);
-    ///
-    /// impl PartialEq for A {
-    ///     fn eq(&self, b: &Self) -> bool {
-    ///         self.0 == b.0
-    ///     }
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// struct A(u32);
-    ///
-    /// impl PartialEq for A {
-    ///     fn eq(&self, other: &Self) -> bool {
-    ///         self.0 == other.0
-    ///     }
+    /// ```no_run
+    /// # struct Color;
+    /// fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {
+    ///     // ..
     /// }
     /// ```
-    #[clippy::version = "1.80.0"]
-    pub RENAMED_FUNCTION_PARAMS,
-    restriction,
-    "renamed function parameters in trait implementation"
+    #[clippy::version = "pre 1.29.0"]
+    pub TOO_MANY_ARGUMENTS,
+    complexity,
+    "functions with too many arguments"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns when a function signature uses `&Option<T>` instead of `Option<&T>`.
+    /// Checks for functions with a large amount of lines.
     ///
     /// ### Why is this bad?
-    /// More flexibility, better memory optimization, and more idiomatic Rust code.
-    ///
-    /// `&Option<T>` in a function signature breaks encapsulation because the caller must own T
-    /// and move it into an Option to call with it. When returned, the owner must internally store
-    /// it as `Option<T>` in order to return it.
-    /// At a lower level, `&Option<T>` points to memory with the `presence` bit flag plus the `T` value,
-    /// whereas `Option<&T>` is usually [optimized](https://doc.rust-lang.org/1.81.0/std/option/index.html#representation)
-    /// to a single pointer, so it may be more optimal.
-    ///
-    /// See this [YouTube video](https://www.youtube.com/watch?v=6c7pZYP_iIE) by
-    /// Logan Smith for an in-depth explanation of why this is important.
-    ///
-    /// ### Known problems
-    /// This lint recommends changing the function signatures, but it cannot
-    /// automatically change the function calls or the function implementations.
+    /// Functions with a lot of lines are harder to understand
+    /// due to having to look at a larger amount of code to understand what the
+    /// function is doing. Consider splitting the body of the function into
+    /// multiple functions.
     ///
     /// ### Example
     /// ```no_run
-    /// // caller uses  foo(&opt)
-    /// fn foo(a: &Option<String>) {}
-    /// # struct Unit {}
-    /// # impl Unit {
-    /// fn bar(&self) -> &Option<String> { &None }
-    /// # }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// // caller should use  `foo1(opt.as_ref())`
-    /// fn foo1(a: Option<&String>) {}
-    /// // better yet, use string slice  `foo2(opt.as_deref())`
-    /// fn foo2(a: Option<&str>) {}
-    /// # struct Unit {}
-    /// # impl Unit {
-    /// fn bar(&self) -> Option<&String> { None }
-    /// # }
+    /// fn im_too_long() {
+    ///     println!("");
+    ///     // ... 100 more LoC
+    ///     println!("");
+    /// }
     /// ```
-    #[clippy::version = "1.83.0"]
-    pub REF_OPTION,
+    #[clippy::version = "1.34.0"]
+    pub TOO_MANY_LINES,
     pedantic,
-    "function signature uses `&Option<T>` instead of `Option<&T>`"
+    "functions with too many lines"
 }
 
 declare_lint_pass!(EarlyFunctions => [DUPLICATE_UNDERSCORE_ARGUMENT]);
 
+impl_lint_pass!(Functions => [
+    DOUBLE_MUST_USE,
+    IMPL_TRAIT_IN_PARAMS,
+    MISNAMED_GETTERS,
+    MUST_USE_CANDIDATE,
+    MUST_USE_UNIT,
+    NOT_UNSAFE_PTR_ARG_DEREF,
+    REF_OPTION,
+    RENAMED_FUNCTION_PARAMS,
+    RESULT_LARGE_ERR,
+    RESULT_UNIT_ERR,
+    TOO_MANY_ARGUMENTS,
+    TOO_MANY_LINES,
+]);
+
 impl EarlyLintPass for EarlyFunctions {
     fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: visit::FnKind<'_>, _: Span, _: ast::NodeId) {
         duplicate_underscore_argument::check(cx, fn_kind);
@@ -515,21 +530,6 @@ impl Functions {
     }
 }
 
-impl_lint_pass!(Functions => [
-    TOO_MANY_ARGUMENTS,
-    TOO_MANY_LINES,
-    NOT_UNSAFE_PTR_ARG_DEREF,
-    MUST_USE_UNIT,
-    DOUBLE_MUST_USE,
-    MUST_USE_CANDIDATE,
-    RESULT_UNIT_ERR,
-    RESULT_LARGE_ERR,
-    MISNAMED_GETTERS,
-    IMPL_TRAIT_IN_PARAMS,
-    RENAMED_FUNCTION_PARAMS,
-    REF_OPTION,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Functions {
     fn check_fn(
         &mut self,
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 9e5e4fa58d2f..2d5ccc0b82b7 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -50,6 +50,8 @@ declare_clippy_lint! {
     "Finds if-else that could be written using either `bool::then` or `bool::then_some`"
 }
 
+impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
+
 pub struct IfThenSomeElseNone {
     msrv: Msrv,
 }
@@ -60,8 +62,6 @@ impl IfThenSomeElseNone {
     }
 }
 
-impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
-
 impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let Some(higher::If {
diff --git a/clippy_lints/src/ifs/mod.rs b/clippy_lints/src/ifs/mod.rs
index 739f2fc91729..8a22d8935368 100644
--- a/clippy_lints/src/ifs/mod.rs
+++ b/clippy_lints/src/ifs/mod.rs
@@ -11,6 +11,62 @@ mod if_same_then_else;
 mod ifs_same_cond;
 mod same_functions_in_if_cond;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if the `if` and `else` block contain shared code that can be
+    /// moved out of the blocks.
+    ///
+    /// ### Why is this bad?
+    /// Duplicate code is less maintainable.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// let foo = if … {
+    ///     println!("Hello World");
+    ///     13
+    /// } else {
+    ///     println!("Hello World");
+    ///     42
+    /// };
+    /// ```
+    ///
+    /// Use instead:
+    /// ```ignore
+    /// println!("Hello World");
+    /// let foo = if … {
+    ///     13
+    /// } else {
+    ///     42
+    /// };
+    /// ```
+    #[clippy::version = "1.53.0"]
+    pub BRANCHES_SHARING_CODE,
+    nursery,
+    "`if` statement with shared code in all blocks"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `if/else` with the same body as the *then* part
+    /// and the *else* part.
+    ///
+    /// ### Why is this bad?
+    /// This is probably a copy & paste error.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// let foo = if … {
+    ///     42
+    /// } else {
+    ///     42
+    /// };
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub IF_SAME_THEN_ELSE,
+    style,
+    "`if` with the same `then` and `else` blocks"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for consecutive `if`s with the same condition.
@@ -91,61 +147,12 @@ declare_clippy_lint! {
     "consecutive `if`s with the same function call"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `if/else` with the same body as the *then* part
-    /// and the *else* part.
-    ///
-    /// ### Why is this bad?
-    /// This is probably a copy & paste error.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// let foo = if … {
-    ///     42
-    /// } else {
-    ///     42
-    /// };
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub IF_SAME_THEN_ELSE,
-    style,
-    "`if` with the same `then` and `else` blocks"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks if the `if` and `else` block contain shared code that can be
-    /// moved out of the blocks.
-    ///
-    /// ### Why is this bad?
-    /// Duplicate code is less maintainable.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// let foo = if … {
-    ///     println!("Hello World");
-    ///     13
-    /// } else {
-    ///     println!("Hello World");
-    ///     42
-    /// };
-    /// ```
-    ///
-    /// Use instead:
-    /// ```ignore
-    /// println!("Hello World");
-    /// let foo = if … {
-    ///     13
-    /// } else {
-    ///     42
-    /// };
-    /// ```
-    #[clippy::version = "1.53.0"]
-    pub BRANCHES_SHARING_CODE,
-    nursery,
-    "`if` statement with shared code in all blocks"
-}
+impl_lint_pass!(CopyAndPaste<'_> => [
+    BRANCHES_SHARING_CODE,
+    IFS_SAME_COND,
+    IF_SAME_THEN_ELSE,
+    SAME_FUNCTIONS_IN_IF_CONDITION,
+]);
 
 pub struct CopyAndPaste<'tcx> {
     interior_mut: InteriorMut<'tcx>,
@@ -159,13 +166,6 @@ impl<'tcx> CopyAndPaste<'tcx> {
     }
 }
 
-impl_lint_pass!(CopyAndPaste<'_> => [
-    IFS_SAME_COND,
-    SAME_FUNCTIONS_IN_IF_CONDITION,
-    IF_SAME_THEN_ELSE,
-    BRANCHES_SHARING_CODE
-]);
-
 impl<'tcx> LateLintPass<'tcx> for CopyAndPaste<'tcx> {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion() && matches!(expr.kind, ExprKind::If(..)) && !is_else_clause(cx.tcx, expr) {
diff --git a/clippy_lints/src/ignored_unit_patterns.rs b/clippy_lints/src/ignored_unit_patterns.rs
index e4ace3bdabf0..cf7b444f6754 100644
--- a/clippy_lints/src/ignored_unit_patterns.rs
+++ b/clippy_lints/src/ignored_unit_patterns.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     pedantic,
     "suggest replacing `_` by `()` in patterns where appropriate"
 }
+
 declare_lint_pass!(IgnoredUnitPatterns => [IGNORED_UNIT_PATTERNS]);
 
 impl<'tcx> LateLintPass<'tcx> for IgnoredUnitPatterns {
diff --git a/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs b/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
index f73182d3af0d..dec08d94e89d 100644
--- a/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
+++ b/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
@@ -69,7 +69,9 @@ declare_clippy_lint! {
     "ensures that the semantics of `Borrow` for `Hash` are satisfied when `Borrow<str>` and `Borrow<[u8]>` are implemented"
 }
 
-declare_lint_pass!(ImplHashWithBorrowStrBytes => [IMPL_HASH_BORROW_WITH_STR_AND_BYTES]);
+declare_lint_pass!(ImplHashWithBorrowStrBytes => [
+    IMPL_HASH_BORROW_WITH_STR_AND_BYTES,
+]);
 
 impl LateLintPass<'_> for ImplHashWithBorrowStrBytes {
     /// We are emitting this lint at the Hash impl of a type that implements all
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index 4bf3a390b050..f0a2ad59cd28 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     style,
     "Perform saturating addition instead of implicitly checking max bound of data type"
 }
+
 declare_lint_pass!(ImplicitSaturatingAdd => [IMPLICIT_SATURATING_ADD]);
 
 impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 516f9e3aa60c..ee3619ea6746 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -79,12 +79,15 @@ declare_clippy_lint! {
     "Check if a variable is smaller than another one and still subtract from it even if smaller"
 }
 
+impl_lint_pass!(ImplicitSaturatingSub => [
+    IMPLICIT_SATURATING_SUB,
+    INVERTED_SATURATING_SUB,
+]);
+
 pub struct ImplicitSaturatingSub {
     msrv: Msrv,
 }
 
-impl_lint_pass!(ImplicitSaturatingSub => [IMPLICIT_SATURATING_SUB, INVERTED_SATURATING_SUB]);
-
 impl ImplicitSaturatingSub {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index 6b89abdb0367..780c789d4fe3 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -47,6 +47,7 @@ declare_clippy_lint! {
     complexity,
     "specifying bounds that are implied by other bounds in `impl Trait` type"
 }
+
 declare_lint_pass!(ImpliedBoundsInImpls => [IMPLIED_BOUNDS_IN_IMPLS]);
 
 fn emit_lint(
diff --git a/clippy_lints/src/incompatible_msrv.rs b/clippy_lints/src/incompatible_msrv.rs
index 8d538ff1acba..2dba6c4bd9e5 100644
--- a/clippy_lints/src/incompatible_msrv.rs
+++ b/clippy_lints/src/incompatible_msrv.rs
@@ -72,6 +72,8 @@ declare_clippy_lint! {
     "ensures that all items used in the crate are available for the current MSRV"
 }
 
+impl_lint_pass!(IncompatibleMsrv => [INCOMPATIBLE_MSRV]);
+
 #[derive(Clone, Copy)]
 enum Availability {
     FeatureEnabled,
@@ -114,8 +116,6 @@ pub struct IncompatibleMsrv {
     called_path: Option<HirId>,
 }
 
-impl_lint_pass!(IncompatibleMsrv => [INCOMPATIBLE_MSRV]);
-
 impl IncompatibleMsrv {
     pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index e6129757e560..4555af85c2d2 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -64,6 +64,10 @@ declare_clippy_lint! {
     "the order of the field init is inconsistent with the order in the struct definition"
 }
 
+impl_lint_pass!(InconsistentStructConstructor => [
+    INCONSISTENT_STRUCT_CONSTRUCTOR,
+]);
+
 pub struct InconsistentStructConstructor {
     check_inconsistent_struct_field_initializers: bool,
 }
@@ -76,8 +80,6 @@ impl InconsistentStructConstructor {
     }
 }
 
-impl_lint_pass!(InconsistentStructConstructor => [INCONSISTENT_STRUCT_CONSTRUCTOR]);
-
 impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         let ExprKind::Struct(_, fields, _) = expr.kind else {
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index e95816353df6..b1f03babb9fa 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -53,6 +53,8 @@ declare_clippy_lint! {
     "avoid indexing on slices which could be destructed"
 }
 
+impl_lint_pass!(IndexRefutableSlice => [INDEX_REFUTABLE_SLICE]);
+
 pub struct IndexRefutableSlice {
     max_suggested_slice: u64,
     msrv: Msrv,
@@ -67,8 +69,6 @@ impl IndexRefutableSlice {
     }
 }
 
-impl_lint_pass!(IndexRefutableSlice => [INDEX_REFUTABLE_SLICE]);
-
 impl<'tcx> LateLintPass<'tcx> for IndexRefutableSlice {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if let Some(IfLet { let_pat, if_then, .. }) = IfLet::hir(cx, expr)
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index e9ddd3ca8ede..e19e02901cae 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -9,36 +9,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::impl_lint_pass;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for out of bounds array indexing with a constant
-    /// index.
-    ///
-    /// ### Why is this bad?
-    /// This will always panic at runtime.
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// let x = [1, 2, 3, 4];
-    ///
-    /// x[9];
-    /// &x[2..9];
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let x = [1, 2, 3, 4];
-    /// // Index within bounds
-    ///
-    /// x[0];
-    /// x[3];
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OUT_OF_BOUNDS_INDEXING,
-    correctness,
-    "out of bounds constant indexing"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of indexing or slicing that may panic at runtime.
@@ -92,6 +62,36 @@ declare_clippy_lint! {
     "indexing/slicing usage"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for out of bounds array indexing with a constant
+    /// index.
+    ///
+    /// ### Why is this bad?
+    /// This will always panic at runtime.
+    ///
+    /// ### Example
+    /// ```rust,no_run
+    /// let x = [1, 2, 3, 4];
+    ///
+    /// x[9];
+    /// &x[2..9];
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let x = [1, 2, 3, 4];
+    /// // Index within bounds
+    ///
+    /// x[0];
+    /// x[3];
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub OUT_OF_BOUNDS_INDEXING,
+    correctness,
+    "out of bounds constant indexing"
+}
+
 impl_lint_pass!(IndexingSlicing => [INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING]);
 
 pub struct IndexingSlicing {
diff --git a/clippy_lints/src/infallible_try_from.rs b/clippy_lints/src/infallible_try_from.rs
index 36df07a43705..511df733ed91 100644
--- a/clippy_lints/src/infallible_try_from.rs
+++ b/clippy_lints/src/infallible_try_from.rs
@@ -40,6 +40,7 @@ declare_clippy_lint! {
     suspicious,
     "TryFrom with infallible Error type"
 }
+
 declare_lint_pass!(InfallibleTryFrom => [INFALLIBLE_TRY_FROM]);
 
 impl<'tcx> LateLintPass<'tcx> for InfallibleTryFrom {
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index e569a5c7b612..22082646eb31 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -88,7 +88,10 @@ declare_clippy_lint! {
     "type implements inherent method `to_string()`, which gets shadowed by the implementation of the `Display` trait"
 }
 
-declare_lint_pass!(InherentToString => [INHERENT_TO_STRING, INHERENT_TO_STRING_SHADOW_DISPLAY]);
+declare_lint_pass!(InherentToString => [
+    INHERENT_TO_STRING,
+    INHERENT_TO_STRING_SHADOW_DISPLAY,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for InherentToString {
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
index 22767901614e..70df856570b2 100644
--- a/clippy_lints/src/item_name_repetitions.rs
+++ b/clippy_lints/src/item_name_repetitions.rs
@@ -45,6 +45,37 @@ declare_clippy_lint! {
     "enums where all variants share a prefix/postfix"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for modules that have the same name as their
+    /// parent module
+    ///
+    /// ### Why is this bad?
+    /// A typical beginner mistake is to have `mod foo;` and
+    /// again `mod foo { ..
+    /// }` in `foo.rs`.
+    /// The expectation is that items inside the inner `mod foo { .. }` are then
+    /// available
+    /// through `foo::x`, but they are only available through
+    /// `foo::foo::x`.
+    /// If this is done on purpose, it would be better to choose a more
+    /// representative module name.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// // lib.rs
+    /// mod foo;
+    /// // foo.rs
+    /// mod foo {
+    ///     ...
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MODULE_INCEPTION,
+    style,
+    "modules that have the same name as their parent module"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Detects public item names that are prefixed or suffixed by the
@@ -89,36 +120,6 @@ declare_clippy_lint! {
     "type names prefixed/postfixed with their containing module's name"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for modules that have the same name as their
-    /// parent module
-    ///
-    /// ### Why is this bad?
-    /// A typical beginner mistake is to have `mod foo;` and
-    /// again `mod foo { ..
-    /// }` in `foo.rs`.
-    /// The expectation is that items inside the inner `mod foo { .. }` are then
-    /// available
-    /// through `foo::x`, but they are only available through
-    /// `foo::foo::x`.
-    /// If this is done on purpose, it would be better to choose a more
-    /// representative module name.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// // lib.rs
-    /// mod foo;
-    /// // foo.rs
-    /// mod foo {
-    ///     ...
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MODULE_INCEPTION,
-    style,
-    "modules that have the same name as their parent module"
-}
 declare_clippy_lint! {
     /// ### What it does
     /// Detects struct fields that are prefixed or suffixed
@@ -155,6 +156,13 @@ declare_clippy_lint! {
     "structs where all fields share a prefix/postfix or contain the name of the struct"
 }
 
+impl_lint_pass!(ItemNameRepetitions => [
+    ENUM_VARIANT_NAMES,
+    MODULE_INCEPTION,
+    MODULE_NAME_REPETITIONS,
+    STRUCT_FIELD_NAMES,
+]);
+
 pub struct ItemNameRepetitions {
     /// The module path the lint pass is in.
     modules: Vec<ModInfo>,
@@ -195,13 +203,6 @@ impl ItemNameRepetitions {
     }
 }
 
-impl_lint_pass!(ItemNameRepetitions => [
-    ENUM_VARIANT_NAMES,
-    STRUCT_FIELD_NAMES,
-    MODULE_NAME_REPETITIONS,
-    MODULE_INCEPTION
-]);
-
 #[must_use]
 fn have_no_extra_prefix(prefixes: &[&str]) -> bool {
     prefixes.iter().all(|p| p == &"" || p == &"_")
diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 645e0f981f27..4e56f9c8472d 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -11,22 +11,30 @@ use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Looks for `iter` and `iter_mut` methods without an associated `IntoIterator for (&|&mut) Type` implementation.
+    /// This is the opposite of the `iter_without_into_iter` lint.
+    /// It looks for `IntoIterator for (&|&mut) Type` implementations without an inherent `iter` or `iter_mut` method
+    /// on the type or on any of the types in its `Deref` chain.
     ///
     /// ### Why is this bad?
-    /// It's not bad, but having them is idiomatic and allows the type to be used in for loops directly
-    /// (`for val in &iter {}`), without having to first call `iter()` or `iter_mut()`.
+    /// It's not bad, but having them is idiomatic and allows the type to be used in iterator chains
+    /// by just calling `.iter()`, instead of the more awkward `<&Type>::into_iter` or `(&val).into_iter()` syntax
+    /// in case of ambiguity with another `IntoIterator` impl.
     ///
     /// ### Limitations
     /// This lint focuses on providing an idiomatic API. Therefore, it will only
     /// lint on types which are accessible outside of the crate. For internal types,
-    /// the `IntoIterator` trait can be implemented on demand if it is actually needed.
+    /// these methods can be added on demand if they are actually needed. Otherwise,
+    /// it would trigger the [`dead_code`] lint for the unused method.
+    ///
+    /// [`dead_code`]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#dead-code
     ///
     /// ### Example
     /// ```no_run
     /// struct MySlice<'a>(&'a [u8]);
-    /// impl<'a> MySlice<'a> {
-    ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
+    /// impl<'a> IntoIterator for &MySlice<'a> {
+    ///     type Item = &'a u8;
+    ///     type IntoIter = std::slice::Iter<'a, u8>;
+    ///     fn into_iter(self) -> Self::IntoIter {
     ///         self.0.iter()
     ///     }
     /// }
@@ -36,49 +44,41 @@ declare_clippy_lint! {
     /// struct MySlice<'a>(&'a [u8]);
     /// impl<'a> MySlice<'a> {
     ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
-    ///         self.0.iter()
+    ///         self.into_iter()
     ///     }
     /// }
     /// impl<'a> IntoIterator for &MySlice<'a> {
     ///     type Item = &'a u8;
     ///     type IntoIter = std::slice::Iter<'a, u8>;
     ///     fn into_iter(self) -> Self::IntoIter {
-    ///         self.iter()
+    ///         self.0.iter()
     ///     }
     /// }
     /// ```
     #[clippy::version = "1.75.0"]
-    pub ITER_WITHOUT_INTO_ITER,
+    pub INTO_ITER_WITHOUT_ITER,
     pedantic,
-    "implementing `iter(_mut)` without an associated `IntoIterator for (&|&mut) Type` impl"
+    "implementing `IntoIterator for (&|&mut) Type` without an inherent `iter(_mut)` method"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// This is the opposite of the `iter_without_into_iter` lint.
-    /// It looks for `IntoIterator for (&|&mut) Type` implementations without an inherent `iter` or `iter_mut` method
-    /// on the type or on any of the types in its `Deref` chain.
+    /// Looks for `iter` and `iter_mut` methods without an associated `IntoIterator for (&|&mut) Type` implementation.
     ///
     /// ### Why is this bad?
-    /// It's not bad, but having them is idiomatic and allows the type to be used in iterator chains
-    /// by just calling `.iter()`, instead of the more awkward `<&Type>::into_iter` or `(&val).into_iter()` syntax
-    /// in case of ambiguity with another `IntoIterator` impl.
+    /// It's not bad, but having them is idiomatic and allows the type to be used in for loops directly
+    /// (`for val in &iter {}`), without having to first call `iter()` or `iter_mut()`.
     ///
     /// ### Limitations
     /// This lint focuses on providing an idiomatic API. Therefore, it will only
     /// lint on types which are accessible outside of the crate. For internal types,
-    /// these methods can be added on demand if they are actually needed. Otherwise,
-    /// it would trigger the [`dead_code`] lint for the unused method.
-    ///
-    /// [`dead_code`]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#dead-code
+    /// the `IntoIterator` trait can be implemented on demand if it is actually needed.
     ///
     /// ### Example
     /// ```no_run
     /// struct MySlice<'a>(&'a [u8]);
-    /// impl<'a> IntoIterator for &MySlice<'a> {
-    ///     type Item = &'a u8;
-    ///     type IntoIter = std::slice::Iter<'a, u8>;
-    ///     fn into_iter(self) -> Self::IntoIter {
+    /// impl<'a> MySlice<'a> {
+    ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
     ///         self.0.iter()
     ///     }
     /// }
@@ -88,24 +88,27 @@ declare_clippy_lint! {
     /// struct MySlice<'a>(&'a [u8]);
     /// impl<'a> MySlice<'a> {
     ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
-    ///         self.into_iter()
+    ///         self.0.iter()
     ///     }
     /// }
     /// impl<'a> IntoIterator for &MySlice<'a> {
     ///     type Item = &'a u8;
     ///     type IntoIter = std::slice::Iter<'a, u8>;
     ///     fn into_iter(self) -> Self::IntoIter {
-    ///         self.0.iter()
+    ///         self.iter()
     ///     }
     /// }
     /// ```
     #[clippy::version = "1.75.0"]
-    pub INTO_ITER_WITHOUT_ITER,
+    pub ITER_WITHOUT_INTO_ITER,
     pedantic,
-    "implementing `IntoIterator for (&|&mut) Type` without an inherent `iter(_mut)` method"
+    "implementing `iter(_mut)` without an associated `IntoIterator for (&|&mut) Type` impl"
 }
 
-declare_lint_pass!(IterWithoutIntoIter => [ITER_WITHOUT_INTO_ITER, INTO_ITER_WITHOUT_ITER]);
+declare_lint_pass!(IterWithoutIntoIter => [
+    INTO_ITER_WITHOUT_ITER,
+    ITER_WITHOUT_INTO_ITER,
+]);
 
 /// Checks if a given type is nameable in a trait (impl).
 /// RPIT is stable, but impl Trait in traits is not (yet), so when we have
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index cee8ca1261e5..383f2721fad2 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -32,6 +32,8 @@ declare_clippy_lint! {
     "large non-scalar const array may cause performance overhead"
 }
 
+impl_lint_pass!(LargeConstArrays => [LARGE_CONST_ARRAYS]);
+
 pub struct LargeConstArrays {
     maximum_allowed_size: u64,
 }
@@ -44,8 +46,6 @@ impl LargeConstArrays {
     }
 }
 
-impl_lint_pass!(LargeConstArrays => [LARGE_CONST_ARRAYS]);
-
 impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Const(ident, generics, _, _) = &item.kind
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index c2b739431060..50767b32bb71 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -58,6 +58,8 @@ declare_clippy_lint! {
     "large size difference between variants on an enum"
 }
 
+impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
+
 pub struct LargeEnumVariant {
     maximum_size_difference_allowed: u64,
 }
@@ -70,8 +72,6 @@ impl LargeEnumVariant {
     }
 }
 
-impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
-
 impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &Item<'tcx>) {
         if let ItemKind::Enum(ident, _, ref def) = item.kind
diff --git a/clippy_lints/src/large_futures.rs b/clippy_lints/src/large_futures.rs
index b11e89a9b566..382d1c1ae3ef 100644
--- a/clippy_lints/src/large_futures.rs
+++ b/clippy_lints/src/large_futures.rs
@@ -40,6 +40,8 @@ declare_clippy_lint! {
     "large future may lead to unexpected stack overflows"
 }
 
+impl_lint_pass!(LargeFuture => [LARGE_FUTURES]);
+
 pub struct LargeFuture {
     future_size_threshold: u64,
 }
@@ -52,8 +54,6 @@ impl LargeFuture {
     }
 }
 
-impl_lint_pass!(LargeFuture => [LARGE_FUTURES]);
-
 impl<'tcx> LateLintPass<'tcx> for LargeFuture {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let ExprKind::Match(scrutinee, _, MatchSource::AwaitDesugar) = expr.kind
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 54599499515e..f0e178e7d72f 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -38,6 +38,8 @@ declare_clippy_lint! {
     "including a large file"
 }
 
+impl_lint_pass!(LargeIncludeFile => [LARGE_INCLUDE_FILE]);
+
 pub struct LargeIncludeFile {
     max_file_size: u64,
 }
@@ -50,8 +52,6 @@ impl LargeIncludeFile {
     }
 }
 
-impl_lint_pass!(LargeIncludeFile => [LARGE_INCLUDE_FILE]);
-
 impl LateLintPass<'_> for LargeIncludeFile {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         if let ExprKind::Lit(lit) = &expr.kind
diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index 32c23a2d0362..e651209de52f 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -29,6 +29,8 @@ declare_clippy_lint! {
     "allocating large arrays on stack may cause stack overflow"
 }
 
+impl_lint_pass!(LargeStackArrays => [LARGE_STACK_ARRAYS]);
+
 pub struct LargeStackArrays {
     maximum_allowed_size: u64,
     prev_vec_macro_callsite: Option<Span>,
@@ -61,8 +63,6 @@ impl LargeStackArrays {
     }
 }
 
-impl_lint_pass!(LargeStackArrays => [LARGE_STACK_ARRAYS]);
-
 impl<'tcx> LateLintPass<'tcx> for LargeStackArrays {
     fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if matches!(item.kind, ItemKind::Static(..) | ItemKind::Const(..)) {
diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index 6b0080d04c44..7cf594384b5a 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -82,6 +82,8 @@ declare_clippy_lint! {
     "checks for functions that allocate a lot of stack space"
 }
 
+impl_lint_pass!(LargeStackFrames => [LARGE_STACK_FRAMES]);
+
 pub struct LargeStackFrames {
     maximum_allowed_size: u64,
     allow_large_stack_frames_in_tests: bool,
@@ -96,8 +98,6 @@ impl LargeStackFrames {
     }
 }
 
-impl_lint_pass!(LargeStackFrames => [LARGE_STACK_FRAMES]);
-
 #[derive(Copy, Clone)]
 enum Space {
     Used(u64),
diff --git a/clippy_lints/src/legacy_numeric_constants.rs b/clippy_lints/src/legacy_numeric_constants.rs
index 8a5d97294d2b..ad8304684650 100644
--- a/clippy_lints/src/legacy_numeric_constants.rs
+++ b/clippy_lints/src/legacy_numeric_constants.rs
@@ -34,6 +34,9 @@ declare_clippy_lint! {
     style,
     "checks for usage of legacy std numeric constants and methods"
 }
+
+impl_lint_pass!(LegacyNumericConstants => [LEGACY_NUMERIC_CONSTANTS]);
+
 pub struct LegacyNumericConstants {
     msrv: Msrv,
 }
@@ -44,8 +47,6 @@ impl LegacyNumericConstants {
     }
 }
 
-impl_lint_pass!(LegacyNumericConstants => [LEGACY_NUMERIC_CONSTANTS]);
-
 impl<'tcx> LateLintPass<'tcx> for LegacyNumericConstants {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         // Integer modules are "TBD" deprecated, and the contents are too,
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 2e576da38b89..d683abd3d33b 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -18,83 +18,83 @@ use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for getting the length of something via `.len()`
-    /// just to compare to zero, and suggests using `.is_empty()` where applicable.
+    /// Checks for comparing to an empty slice such as `""` or `[]`,
+    /// and suggests using `.is_empty()` where applicable.
     ///
     /// ### Why is this bad?
     /// Some structures can answer `.is_empty()` much faster
-    /// than calculating their length. So it is good to get into the habit of using
+    /// than checking for equality. So it is good to get into the habit of using
     /// `.is_empty()`, and having it is cheap.
     /// Besides, it makes the intent clearer than a manual comparison in some contexts.
     ///
     /// ### Example
+    ///
     /// ```ignore
-    /// if x.len() == 0 {
+    /// if s == "" {
     ///     ..
     /// }
-    /// if y.len() != 0 {
+    ///
+    /// if arr == [] {
     ///     ..
     /// }
     /// ```
-    /// instead use
+    /// Use instead:
     /// ```ignore
-    /// if x.is_empty() {
+    /// if s.is_empty() {
     ///     ..
     /// }
-    /// if !y.is_empty() {
+    ///
+    /// if arr.is_empty() {
     ///     ..
     /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub LEN_ZERO,
+    #[clippy::version = "1.49.0"]
+    pub COMPARISON_TO_EMPTY,
     style,
-    "checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` could be used instead"
+    "checking `x == \"\"` or `x == []` (or similar) when `.is_empty()` could be used instead"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for comparing to an empty slice such as `""` or `[]`,
-    /// and suggests using `.is_empty()` where applicable.
+    /// Checks for getting the length of something via `.len()`
+    /// just to compare to zero, and suggests using `.is_empty()` where applicable.
     ///
     /// ### Why is this bad?
     /// Some structures can answer `.is_empty()` much faster
-    /// than checking for equality. So it is good to get into the habit of using
+    /// than calculating their length. So it is good to get into the habit of using
     /// `.is_empty()`, and having it is cheap.
     /// Besides, it makes the intent clearer than a manual comparison in some contexts.
     ///
     /// ### Example
-    ///
     /// ```ignore
-    /// if s == "" {
+    /// if x.len() == 0 {
     ///     ..
     /// }
-    ///
-    /// if arr == [] {
+    /// if y.len() != 0 {
     ///     ..
     /// }
     /// ```
-    /// Use instead:
+    /// instead use
     /// ```ignore
-    /// if s.is_empty() {
+    /// if x.is_empty() {
     ///     ..
     /// }
-    ///
-    /// if arr.is_empty() {
+    /// if !y.is_empty() {
     ///     ..
     /// }
     /// ```
-    #[clippy::version = "1.49.0"]
-    pub COMPARISON_TO_EMPTY,
+    #[clippy::version = "pre 1.29.0"]
+    pub LEN_ZERO,
     style,
-    "checking `x == \"\"` or `x == []` (or similar) when `.is_empty()` could be used instead"
+    "checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` could be used instead"
 }
 
+impl_lint_pass!(LenZero => [COMPARISON_TO_EMPTY, LEN_ZERO]);
+
 pub struct LenZero {
     msrv: Msrv,
 }
 
-impl_lint_pass!(LenZero => [LEN_ZERO, COMPARISON_TO_EMPTY]);
-
 impl LenZero {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index b72e14246db7..984574c221fb 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -9,25 +9,33 @@ use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `let _ = <expr>` where expr is `#[must_use]`
+    /// Checks for `let _ = <expr>` where the resulting type of expr implements `Future`
     ///
-    /// ### Why restrict this?
-    /// To ensure that all `#[must_use]` types are used rather than ignored.
+    /// ### Why is this bad?
+    /// Futures must be polled for work to be done. The original intention was most likely to await the future
+    /// and ignore the resulting value.
     ///
     /// ### Example
     /// ```no_run
-    /// fn f() -> Result<u32, u32> {
-    ///     Ok(0)
+    /// async fn foo() -> Result<(), ()> {
+    ///     Ok(())
     /// }
+    /// let _ = foo();
+    /// ```
     ///
-    /// let _ = f();
-    /// // is_ok() is marked #[must_use]
-    /// let _ = f().is_ok();
+    /// Use instead:
+    /// ```no_run
+    /// # async fn context() {
+    /// async fn foo() -> Result<(), ()> {
+    ///     Ok(())
+    /// }
+    /// let _ = foo().await;
+    /// # }
     /// ```
-    #[clippy::version = "1.42.0"]
-    pub LET_UNDERSCORE_MUST_USE,
-    restriction,
-    "non-binding `let` on a `#[must_use]` expression"
+    #[clippy::version = "1.67.0"]
+    pub LET_UNDERSCORE_FUTURE,
+    suspicious,
+    "non-binding `let` on a future"
 }
 
 declare_clippy_lint! {
@@ -60,33 +68,25 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `let _ = <expr>` where the resulting type of expr implements `Future`
+    /// Checks for `let _ = <expr>` where expr is `#[must_use]`
     ///
-    /// ### Why is this bad?
-    /// Futures must be polled for work to be done. The original intention was most likely to await the future
-    /// and ignore the resulting value.
+    /// ### Why restrict this?
+    /// To ensure that all `#[must_use]` types are used rather than ignored.
     ///
     /// ### Example
     /// ```no_run
-    /// async fn foo() -> Result<(), ()> {
-    ///     Ok(())
+    /// fn f() -> Result<u32, u32> {
+    ///     Ok(0)
     /// }
-    /// let _ = foo();
-    /// ```
     ///
-    /// Use instead:
-    /// ```no_run
-    /// # async fn context() {
-    /// async fn foo() -> Result<(), ()> {
-    ///     Ok(())
-    /// }
-    /// let _ = foo().await;
-    /// # }
+    /// let _ = f();
+    /// // is_ok() is marked #[must_use]
+    /// let _ = f().is_ok();
     /// ```
-    #[clippy::version = "1.67.0"]
-    pub LET_UNDERSCORE_FUTURE,
-    suspicious,
-    "non-binding `let` on a future"
+    #[clippy::version = "1.42.0"]
+    pub LET_UNDERSCORE_MUST_USE,
+    restriction,
+    "non-binding `let` on a `#[must_use]` expression"
 }
 
 declare_clippy_lint! {
@@ -127,7 +127,12 @@ declare_clippy_lint! {
     "non-binding `let` without a type annotation"
 }
 
-declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_FUTURE, LET_UNDERSCORE_UNTYPED]);
+declare_lint_pass!(LetUnderscore => [
+    LET_UNDERSCORE_FUTURE,
+    LET_UNDERSCORE_LOCK,
+    LET_UNDERSCORE_MUST_USE,
+    LET_UNDERSCORE_UNTYPED,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &LetStmt<'tcx>) {
diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index 24a4c321bdab..7f2687664c68 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -24,6 +24,7 @@ declare_clippy_lint! {
     complexity,
     "unneeded underscore type (`_`) in a variable declaration"
 }
+
 declare_lint_pass!(UnderscoreTyped => [LET_WITH_TYPE_UNDERSCORE]);
 
 impl EarlyLintPass for UnderscoreTyped {
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 679fb983d532..0bb4992cf6bb 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -27,41 +27,6 @@ use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::{Ident, kw};
 use std::ops::ControlFlow;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for lifetime annotations which can be removed by
-    /// relying on lifetime elision.
-    ///
-    /// ### Why is this bad?
-    /// The additional lifetimes make the code look more
-    /// complicated, while there is nothing out of the ordinary going on. Removing
-    /// them leads to more readable code.
-    ///
-    /// ### Known problems
-    /// This lint ignores functions with `where` clauses that reference
-    /// lifetimes to prevent false positives.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// // Unnecessary lifetime annotations
-    /// fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 {
-    ///     x
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// fn elided(x: &u8, y: u8) -> &u8 {
-    ///     x
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NEEDLESS_LIFETIMES,
-    complexity,
-    "using explicit lifetimes for references in function arguments when elision rules \
-     would allow omitting them"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for lifetime annotations which can be replaced with anonymous lifetimes (`'_`).
@@ -124,6 +89,47 @@ declare_clippy_lint! {
     "unused lifetimes in function definitions"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for lifetime annotations which can be removed by
+    /// relying on lifetime elision.
+    ///
+    /// ### Why is this bad?
+    /// The additional lifetimes make the code look more
+    /// complicated, while there is nothing out of the ordinary going on. Removing
+    /// them leads to more readable code.
+    ///
+    /// ### Known problems
+    /// This lint ignores functions with `where` clauses that reference
+    /// lifetimes to prevent false positives.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // Unnecessary lifetime annotations
+    /// fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 {
+    ///     x
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// fn elided(x: &u8, y: u8) -> &u8 {
+    ///     x
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NEEDLESS_LIFETIMES,
+    complexity,
+    "using explicit lifetimes for references in function arguments when elision rules \
+     would allow omitting them"
+}
+
+impl_lint_pass!(Lifetimes => [
+    ELIDABLE_LIFETIME_NAMES,
+    EXTRA_UNUSED_LIFETIMES,
+    NEEDLESS_LIFETIMES,
+]);
+
 pub struct Lifetimes {
     msrv: Msrv,
 }
@@ -134,12 +140,6 @@ impl Lifetimes {
     }
 }
 
-impl_lint_pass!(Lifetimes => [
-    NEEDLESS_LIFETIMES,
-    ELIDABLE_LIFETIME_NAMES,
-    EXTRA_UNUSED_LIFETIMES,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Lifetimes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Fn {
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 7cbfa2d097ae..2ec046c8d6ba 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -12,16 +12,37 @@ use std::iter;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns if a long integral or floating-point constant does
-    /// not contain underscores.
+    /// Warns if there is a better representation for a numeric literal.
+    ///
+    /// ### Why restrict this?
+    /// Especially for big powers of 2, a hexadecimal representation is usually more
+    /// readable than a decimal representation.
+    ///
+    /// ### Example
+    /// ```text
+    /// `255` => `0xFF`
+    /// `65_535` => `0xFFFF`
+    /// `4_042_322_160` => `0xF0F0_F0F0`
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DECIMAL_LITERAL_REPRESENTATION,
+    restriction,
+    "using decimal representation when hexadecimal would be better"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns if an integral or floating-point constant is
+    /// grouped inconsistently with underscores.
     ///
     /// ### Why is this bad?
-    /// Reading long numbers is difficult without separators.
+    /// Readers may incorrectly interpret inconsistently
+    /// grouped digits.
     ///
     /// ### Example
     /// ```no_run
     /// # let _: u64 =
-    /// 61864918973511
+    /// 618_64_9189_73_511
     /// # ;
     /// ```
     ///
@@ -32,9 +53,28 @@ declare_clippy_lint! {
     /// # ;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub UNREADABLE_LITERAL,
+    pub INCONSISTENT_DIGIT_GROUPING,
+    style,
+    "integer literals with digits grouped inconsistently"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns if the digits of an integral or floating-point
+    /// constant are grouped into groups that
+    /// are too large.
+    ///
+    /// ### Why is this bad?
+    /// Negatively impacts readability.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: u64 = 6186491_8973511;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub LARGE_DIGIT_GROUPS,
     pedantic,
-    "long literal without underscores"
+    "grouping digits into groups that are too large"
 }
 
 declare_clippy_lint! {
@@ -61,17 +101,16 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns if an integral or floating-point constant is
-    /// grouped inconsistently with underscores.
+    /// Warns if a long integral or floating-point constant does
+    /// not contain underscores.
     ///
     /// ### Why is this bad?
-    /// Readers may incorrectly interpret inconsistently
-    /// grouped digits.
+    /// Reading long numbers is difficult without separators.
     ///
     /// ### Example
     /// ```no_run
     /// # let _: u64 =
-    /// 618_64_9189_73_511
+    /// 61864918973511
     /// # ;
     /// ```
     ///
@@ -82,9 +121,9 @@ declare_clippy_lint! {
     /// # ;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub INCONSISTENT_DIGIT_GROUPING,
-    style,
-    "integer literals with digits grouped inconsistently"
+    pub UNREADABLE_LITERAL,
+    pedantic,
+    "long literal without underscores"
 }
 
 declare_clippy_lint! {
@@ -106,44 +145,15 @@ declare_clippy_lint! {
     "binary or hex literals that aren't grouped by four"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns if the digits of an integral or floating-point
-    /// constant are grouped into groups that
-    /// are too large.
-    ///
-    /// ### Why is this bad?
-    /// Negatively impacts readability.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: u64 = 6186491_8973511;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub LARGE_DIGIT_GROUPS,
-    pedantic,
-    "grouping digits into groups that are too large"
-}
+impl_lint_pass!(DecimalLiteralRepresentation => [DECIMAL_LITERAL_REPRESENTATION]);
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns if there is a better representation for a numeric literal.
-    ///
-    /// ### Why restrict this?
-    /// Especially for big powers of 2, a hexadecimal representation is usually more
-    /// readable than a decimal representation.
-    ///
-    /// ### Example
-    /// ```text
-    /// `255` => `0xFF`
-    /// `65_535` => `0xFFFF`
-    /// `4_042_322_160` => `0xF0F0_F0F0`
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DECIMAL_LITERAL_REPRESENTATION,
-    restriction,
-    "using decimal representation when hexadecimal would be better"
-}
+impl_lint_pass!(LiteralDigitGrouping => [
+    INCONSISTENT_DIGIT_GROUPING,
+    LARGE_DIGIT_GROUPS,
+    MISTYPED_LITERAL_SUFFIXES,
+    UNREADABLE_LITERAL,
+    UNUSUAL_BYTE_GROUPINGS,
+]);
 
 enum WarningType {
     UnreadableLiteral,
@@ -195,14 +205,6 @@ pub struct LiteralDigitGrouping {
     lint_fraction_readability: bool,
 }
 
-impl_lint_pass!(LiteralDigitGrouping => [
-    UNREADABLE_LITERAL,
-    INCONSISTENT_DIGIT_GROUPING,
-    LARGE_DIGIT_GROUPS,
-    MISTYPED_LITERAL_SUFFIXES,
-    UNUSUAL_BYTE_GROUPINGS,
-]);
-
 impl EarlyLintPass for LiteralDigitGrouping {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if let ExprKind::Lit(lit) = expr.kind
@@ -414,8 +416,6 @@ pub struct DecimalLiteralRepresentation {
     threshold: u64,
 }
 
-impl_lint_pass!(DecimalLiteralRepresentation => [DECIMAL_LITERAL_REPRESENTATION]);
-
 impl EarlyLintPass for DecimalLiteralRepresentation {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if let ExprKind::Lit(lit) = expr.kind
diff --git a/clippy_lints/src/literal_string_with_formatting_args.rs b/clippy_lints/src/literal_string_with_formatting_args.rs
index 244e7c95122e..2751a7edc1ae 100644
--- a/clippy_lints/src/literal_string_with_formatting_args.rs
+++ b/clippy_lints/src/literal_string_with_formatting_args.rs
@@ -36,7 +36,9 @@ declare_clippy_lint! {
     "Checks if string literals have formatting arguments"
 }
 
-declare_lint_pass!(LiteralStringWithFormattingArg => [LITERAL_STRING_WITH_FORMATTING_ARGS]);
+declare_lint_pass!(LiteralStringWithFormattingArg => [
+    LITERAL_STRING_WITH_FORMATTING_ARGS,
+]);
 
 fn emit_lint(cx: &LateContext<'_>, expr: &Expr<'_>, spans: &[(Span, Option<String>)]) {
     if !spans.is_empty()
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 83574cab6b67..f89ea531d583 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -37,62 +37,140 @@ use utils::{IncrementVisitor, InitializeVisitor, make_iterator_snippet};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for for-loops that manually copy items between
-    /// slices that could be optimized by having a memcpy.
+    /// Checks for usage of a character position yielded by `.chars().enumerate()` in a context where a **byte index** is expected,
+    /// such as an argument to a specific `str` method or indexing into a `str` or `String`.
     ///
     /// ### Why is this bad?
-    /// It is not as fast as a memcpy.
+    /// A character (more specifically, a Unicode scalar value) that is yielded by `str::chars` can take up multiple bytes,
+    /// so a character position does not necessarily have the same byte index at which the character is stored.
+    /// Thus, using the character position where a byte index is expected can unexpectedly return wrong values
+    /// or panic when the string consists of multibyte characters.
+    ///
+    /// For example, the character `a` in `äa` is stored at byte index 2 but has the character position 1.
+    /// Using the character position 1 to index into the string will lead to a panic as it is in the middle of the first character.
+    ///
+    /// Instead of `.chars().enumerate()`, the correct iterator to use is `.char_indices()`, which yields byte indices.
+    ///
+    /// This pattern is technically fine if the strings are known to only use the ASCII subset,
+    /// though in those cases it would be better to use `bytes()` directly to make the intent clearer,
+    /// but there is also no downside to just using `.char_indices()` directly and supporting non-ASCII strings.
+    ///
+    /// You may also want to read the [chapter on strings in the Rust Book](https://doc.rust-lang.org/book/ch08-02-strings.html)
+    /// which goes into this in more detail.
     ///
     /// ### Example
     /// ```no_run
-    /// # let src = vec![1];
-    /// # let mut dst = vec![0; 65];
-    /// for i in 0..src.len() {
-    ///     dst[i + 64] = src[i];
+    /// # let s = "...";
+    /// for (idx, c) in s.chars().enumerate() {
+    ///     let _ = s[idx..]; // ⚠️ Panics for strings consisting of multibyte characters
     /// }
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let src = vec![1];
-    /// # let mut dst = vec![0; 65];
-    /// dst[64..(src.len() + 64)].clone_from_slice(&src[..]);
+    /// # let s = "...";
+    /// for (idx, c) in s.char_indices() {
+    ///     let _ = s[idx..];
+    /// }
+    /// ```
+    #[clippy::version = "1.88.0"]
+    pub CHAR_INDICES_AS_BYTE_INDICES,
+    correctness,
+    "using the character position yielded by `.chars().enumerate()` in a context where a byte index is expected"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for empty `loop` expressions.
+    ///
+    /// ### Why is this bad?
+    /// These busy loops burn CPU cycles without doing
+    /// anything. It is _almost always_ a better idea to `panic!` than to have
+    /// a busy loop.
+    ///
+    /// If panicking isn't possible, think of the environment and either:
+    ///   - block on something
+    ///   - sleep the thread for some microseconds
+    ///   - yield or pause the thread
+    ///
+    /// For `std` targets, this can be done with
+    /// [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)
+    /// or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).
+    ///
+    /// For `no_std` targets, doing this is more complicated, especially because
+    /// `#[panic_handler]`s can't panic. To stop/pause the thread, you will
+    /// probably need to invoke some target-specific intrinsic. Examples include:
+    ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)
+    ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)
+    ///
+    /// ### Example
+    /// ```no_run
+    /// loop {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub MANUAL_MEMCPY,
-    perf,
-    "manually copying items between slices"
+    pub EMPTY_LOOP,
+    suspicious,
+    "empty `loop {}`, which should block or sleep"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for looping over the range of `0..len` of some
-    /// collection just to get the values by index.
+    /// Checks `for` loops over slices with an explicit counter
+    /// and suggests the use of `.enumerate()`.
     ///
     /// ### Why is this bad?
-    /// Just iterating the collection itself makes the intent
-    /// more clear and is probably faster because it eliminates
-    /// the bounds check that is done when indexing.
+    /// Using `.enumerate()` makes the intent more clear,
+    /// declutters the code and may be faster in some instances.
     ///
     /// ### Example
     /// ```no_run
-    /// let vec = vec!['a', 'b', 'c'];
-    /// for i in 0..vec.len() {
-    ///     println!("{}", vec[i]);
+    /// # let v = vec![1];
+    /// # fn bar(bar: usize, baz: usize) {}
+    /// let mut i = 0;
+    /// for item in &v {
+    ///     bar(i, *item);
+    ///     i += 1;
     /// }
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// let vec = vec!['a', 'b', 'c'];
-    /// for i in vec {
-    ///     println!("{}", i);
+    /// # let v = vec![1];
+    /// # fn bar(bar: usize, baz: usize) {}
+    /// for (i, item) in v.iter().enumerate() { bar(i, *item); }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub EXPLICIT_COUNTER_LOOP,
+    complexity,
+    "for-looping with an explicit counter when `_.enumerate()` would do"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for loops on `y.into_iter()` where `y` will do, and
+    /// suggests the latter.
+    ///
+    /// ### Why is this bad?
+    /// Readability.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let y = vec![1];
+    /// // with `y` a `Vec` or slice:
+    /// for x in y.into_iter() {
+    ///     // ..
+    /// }
+    /// ```
+    /// can be rewritten to
+    /// ```no_run
+    /// # let y = vec![1];
+    /// for x in y {
+    ///     // ..
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub NEEDLESS_RANGE_LOOP,
-    style,
-    "for-looping over a range of indices where an iterator over items would do"
+    pub EXPLICIT_INTO_ITER_LOOP,
+    pedantic,
+    "for-looping over `_.into_iter()` when `_` would do"
 }
 
 declare_clippy_lint! {
@@ -131,31 +209,73 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for loops on `y.into_iter()` where `y` will do, and
-    /// suggests the latter.
+    /// Checks for iterating a map (`HashMap` or `BTreeMap`) and
+    /// ignoring either the keys or values.
     ///
     /// ### Why is this bad?
-    /// Readability.
+    /// Readability. There are `keys` and `values` methods that
+    /// can be used to express that don't need the values or keys.
     ///
     /// ### Example
-    /// ```no_run
-    /// # let y = vec![1];
-    /// // with `y` a `Vec` or slice:
-    /// for x in y.into_iter() {
-    ///     // ..
+    /// ```ignore
+    /// for (k, _) in &map {
+    ///     ..
     /// }
     /// ```
-    /// can be rewritten to
-    /// ```no_run
-    /// # let y = vec![1];
-    /// for x in y {
-    ///     // ..
+    ///
+    /// could be replaced by
+    ///
+    /// ```ignore
+    /// for k in map.keys() {
+    ///     ..
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub EXPLICIT_INTO_ITER_LOOP,
-    pedantic,
-    "for-looping over `_.into_iter()` when `_` would do"
+    pub FOR_KV_MAP,
+    style,
+    "looping on a map using `iter` when `keys` or `values` would do"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for infinite loops in a function where the return type is not `!`
+    /// and lint accordingly.
+    ///
+    /// ### Why restrict this?
+    /// Making the return type `!` serves as documentation that the function does not return.
+    /// If the function is not intended to loop infinitely, then this lint may detect a bug.
+    ///
+    /// ### Example
+    /// ```no_run,ignore
+    /// fn run_forever() {
+    ///     loop {
+    ///         // do something
+    ///     }
+    /// }
+    /// ```
+    /// If infinite loops are as intended:
+    /// ```no_run,ignore
+    /// fn run_forever() -> ! {
+    ///     loop {
+    ///         // do something
+    ///     }
+    /// }
+    /// ```
+    /// Otherwise add a `break` or `return` condition:
+    /// ```no_run,ignore
+    /// fn run_forever() {
+    ///     loop {
+    ///         // do something
+    ///         if condition {
+    ///             break;
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub INFINITE_LOOP,
+    restriction,
+    "possibly unintended infinite loop"
 }
 
 declare_clippy_lint! {
@@ -184,179 +304,185 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detects `loop + match` combinations that are easier
-    /// written as a `while let` loop.
+    /// Checks for manual implementations of Iterator::find
     ///
     /// ### Why is this bad?
-    /// The `while let` loop is usually shorter and more
-    /// readable.
+    /// It doesn't affect performance, but using `find` is shorter and easier to read.
     ///
     /// ### Example
-    /// ```rust,no_run
-    /// let y = Some(1);
-    /// loop {
-    ///     let x = match y {
-    ///         Some(x) => x,
-    ///         None => break,
-    ///     };
-    ///     // ..
+    ///
+    /// ```no_run
+    /// fn example(arr: Vec<i32>) -> Option<i32> {
+    ///     for el in arr {
+    ///         if el == 1 {
+    ///             return Some(el);
+    ///         }
+    ///     }
+    ///     None
     /// }
     /// ```
     /// Use instead:
-    /// ```rust,no_run
-    /// let y = Some(1);
-    /// while let Some(x) = y {
-    ///     // ..
-    /// };
+    /// ```no_run
+    /// fn example(arr: Vec<i32>) -> Option<i32> {
+    ///     arr.into_iter().find(|&el| el == 1)
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub WHILE_LET_LOOP,
+    #[clippy::version = "1.64.0"]
+    pub MANUAL_FIND,
     complexity,
-    "`loop { if let { ... } else break }`, which can be written as a `while let` loop"
+    "manual implementation of `Iterator::find`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks `for` loops over slices with an explicit counter
-    /// and suggests the use of `.enumerate()`.
+    /// Checks for unnecessary `if let` usage in a for loop
+    /// where only the `Some` or `Ok` variant of the iterator element is used.
     ///
     /// ### Why is this bad?
-    /// Using `.enumerate()` makes the intent more clear,
-    /// declutters the code and may be faster in some instances.
+    /// It is verbose and can be simplified
+    /// by first calling the `flatten` method on the `Iterator`.
     ///
     /// ### Example
+    ///
     /// ```no_run
-    /// # let v = vec![1];
-    /// # fn bar(bar: usize, baz: usize) {}
-    /// let mut i = 0;
-    /// for item in &v {
-    ///     bar(i, *item);
-    ///     i += 1;
+    /// let x = vec![Some(1), Some(2), Some(3)];
+    /// for n in x {
+    ///     if let Some(n) = n {
+    ///         println!("{}", n);
+    ///     }
     /// }
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let v = vec![1];
-    /// # fn bar(bar: usize, baz: usize) {}
-    /// for (i, item) in v.iter().enumerate() { bar(i, *item); }
+    /// let x = vec![Some(1), Some(2), Some(3)];
+    /// for n in x.into_iter().flatten() {
+    ///     println!("{}", n);
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EXPLICIT_COUNTER_LOOP,
+    #[clippy::version = "1.52.0"]
+    pub MANUAL_FLATTEN,
     complexity,
-    "for-looping with an explicit counter when `_.enumerate()` would do"
+    "for loops over `Option`s or `Result`s with a single expression can be simplified"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for empty `loop` expressions.
+    /// Checks for for-loops that manually copy items between
+    /// slices that could be optimized by having a memcpy.
     ///
     /// ### Why is this bad?
-    /// These busy loops burn CPU cycles without doing
-    /// anything. It is _almost always_ a better idea to `panic!` than to have
-    /// a busy loop.
-    ///
-    /// If panicking isn't possible, think of the environment and either:
-    ///   - block on something
-    ///   - sleep the thread for some microseconds
-    ///   - yield or pause the thread
-    ///
-    /// For `std` targets, this can be done with
-    /// [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)
-    /// or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).
-    ///
-    /// For `no_std` targets, doing this is more complicated, especially because
-    /// `#[panic_handler]`s can't panic. To stop/pause the thread, you will
-    /// probably need to invoke some target-specific intrinsic. Examples include:
-    ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)
-    ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)
+    /// It is not as fast as a memcpy.
     ///
     /// ### Example
     /// ```no_run
-    /// loop {}
+    /// # let src = vec![1];
+    /// # let mut dst = vec![0; 65];
+    /// for i in 0..src.len() {
+    ///     dst[i + 64] = src[i];
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let src = vec![1];
+    /// # let mut dst = vec![0; 65];
+    /// dst[64..(src.len() + 64)].clone_from_slice(&src[..]);
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub EMPTY_LOOP,
-    suspicious,
-    "empty `loop {}`, which should block or sleep"
+    pub MANUAL_MEMCPY,
+    perf,
+    "manually copying items between slices"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `while let` expressions on iterators.
+    /// Checks for manually filling a slice with a value.
     ///
     /// ### Why is this bad?
-    /// Readability. A simple `for` loop is shorter and conveys
-    /// the intent better.
+    /// Using the `fill` method is more idiomatic and concise.
     ///
     /// ### Example
-    /// ```ignore
-    /// while let Some(val) = iter.next() {
-    ///     ..
+    /// ```no_run
+    /// let mut some_slice = [1, 2, 3, 4, 5];
+    /// for i in 0..some_slice.len() {
+    ///     some_slice[i] = 0;
     /// }
     /// ```
-    ///
     /// Use instead:
-    /// ```ignore
-    /// for val in &mut iter {
-    ///     ..
-    /// }
+    /// ```no_run
+    /// let mut some_slice = [1, 2, 3, 4, 5];
+    /// some_slice.fill(0);
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub WHILE_LET_ON_ITERATOR,
+    #[clippy::version = "1.86.0"]
+    pub MANUAL_SLICE_FILL,
     style,
-    "using a `while let` loop instead of a for loop on an iterator"
+    "manually filling a slice with a value"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for iterating a map (`HashMap` or `BTreeMap`) and
-    /// ignoring either the keys or values.
+    /// Looks for loops that check for emptiness of a `Vec` in the condition and pop an element
+    /// in the body as a separate operation.
     ///
     /// ### Why is this bad?
-    /// Readability. There are `keys` and `values` methods that
-    /// can be used to express that don't need the values or keys.
+    /// Such loops can be written in a more idiomatic way by using a while-let loop and directly
+    /// pattern matching on the return value of `Vec::pop()`.
     ///
     /// ### Example
-    /// ```ignore
-    /// for (k, _) in &map {
-    ///     ..
+    /// ```no_run
+    /// let mut numbers = vec![1, 2, 3, 4, 5];
+    /// while !numbers.is_empty() {
+    ///     let number = numbers.pop().unwrap();
+    ///     // use `number`
     /// }
     /// ```
-    ///
-    /// could be replaced by
-    ///
-    /// ```ignore
-    /// for k in map.keys() {
-    ///     ..
+    /// Use instead:
+    /// ```no_run
+    /// let mut numbers = vec![1, 2, 3, 4, 5];
+    /// while let Some(number) = numbers.pop() {
+    ///     // use `number`
     /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FOR_KV_MAP,
+    #[clippy::version = "1.71.0"]
+    pub MANUAL_WHILE_LET_SOME,
     style,
-    "looping on a map using `iter` when `keys` or `values` would do"
+    "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for loops that will always `break`, `return` or
-    /// `continue` an outer loop.
+    /// Checks for empty spin loops
     ///
     /// ### Why is this bad?
-    /// This loop never loops, all it does is obfuscating the
-    /// code.
+    /// The loop body should have something like `thread::park()` or at least
+    /// `std::hint::spin_loop()` to avoid needlessly burning cycles and conserve
+    /// energy. Perhaps even better use an actual lock, if possible.
+    ///
+    /// ### Known problems
+    /// This lint doesn't currently trigger on `while let` or
+    /// `loop { match .. { .. } }` loops, which would be considered idiomatic in
+    /// combination with e.g. `AtomicBool::compare_exchange_weak`.
     ///
     /// ### Example
-    /// ```no_run
-    /// loop {
-    ///     ..;
-    ///     break;
+    ///
+    /// ```ignore
+    /// use core::sync::atomic::{AtomicBool, Ordering};
+    /// let b = AtomicBool::new(true);
+    /// // give a ref to `b` to another thread,wait for it to become false
+    /// while b.load(Ordering::Acquire) {};
+    /// ```
+    /// Use instead:
+    /// ```rust,no_run
+    ///# use core::sync::atomic::{AtomicBool, Ordering};
+    ///# let b = AtomicBool::new(true);
+    /// while b.load(Ordering::Acquire) {
+    ///     std::hint::spin_loop()
     /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NEVER_LOOP,
-    correctness,
-    "any loop that will always `break` or `return`"
+    #[clippy::version = "1.61.0"]
+    pub MISSING_SPIN_LOOP,
+    perf,
+    "An empty busy waiting loop"
 }
 
 declare_clippy_lint! {
@@ -397,62 +523,55 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks whether variables used within while loop condition
-    /// can be (and are) mutated in the body.
+    /// Checks for looping over the range of `0..len` of some
+    /// collection just to get the values by index.
     ///
     /// ### Why is this bad?
-    /// If the condition is unchanged, entering the body of the loop
-    /// will lead to an infinite loop.
-    ///
-    /// ### Known problems
-    /// If the `while`-loop is in a closure, the check for mutation of the
-    /// condition variables in the body can cause false negatives. For example when only `Upvar` `a` is
-    /// in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.
+    /// Just iterating the collection itself makes the intent
+    /// more clear and is probably faster because it eliminates
+    /// the bounds check that is done when indexing.
     ///
     /// ### Example
     /// ```no_run
-    /// let i = 0;
-    /// while i > 10 {
-    ///     println!("let me loop forever!");
+    /// let vec = vec!['a', 'b', 'c'];
+    /// for i in 0..vec.len() {
+    ///     println!("{}", vec[i]);
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let vec = vec!['a', 'b', 'c'];
+    /// for i in vec {
+    ///     println!("{}", i);
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub WHILE_IMMUTABLE_CONDITION,
-    correctness,
-    "variables used within while expression are not mutated in the body"
+    pub NEEDLESS_RANGE_LOOP,
+    style,
+    "for-looping over a range of indices where an iterator over items would do"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for while loops comparing floating point values.
+    /// Checks for loops that will always `break`, `return` or
+    /// `continue` an outer loop.
     ///
     /// ### Why is this bad?
-    /// If you increment floating point values, errors can compound,
-    /// so, use integers instead if possible.
-    ///
-    /// ### Known problems
-    /// The lint will catch all while loops comparing floating point
-    /// values without regarding the increment.
+    /// This loop never loops, all it does is obfuscating the
+    /// code.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut x = 0.0;
-    /// while x < 42.0 {
-    ///     x += 1.0;
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let mut x = 0;
-    /// while x < 42 {
-    ///     x += 1;
+    /// loop {
+    ///     ..;
+    ///     break;
     /// }
     /// ```
-    #[clippy::version = "1.80.0"]
-    pub WHILE_FLOAT,
-    nursery,
-    "while loops comparing floating point values"
+    #[clippy::version = "pre 1.29.0"]
+    pub NEVER_LOOP,
+    correctness,
+    "any loop that will always `break` or `return`"
 }
 
 declare_clippy_lint! {
@@ -521,270 +640,178 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for unnecessary `if let` usage in a for loop
-    /// where only the `Some` or `Ok` variant of the iterator element is used.
+    /// Checks for uses of the `enumerate` method where the index is unused (`_`)
     ///
     /// ### Why is this bad?
-    /// It is verbose and can be simplified
-    /// by first calling the `flatten` method on the `Iterator`.
+    /// The index from `.enumerate()` is immediately dropped.
     ///
     /// ### Example
-    ///
-    /// ```no_run
-    /// let x = vec![Some(1), Some(2), Some(3)];
-    /// for n in x {
-    ///     if let Some(n) = n {
-    ///         println!("{}", n);
-    ///     }
+    /// ```rust
+    /// let v = vec![1, 2, 3, 4];
+    /// for (_, x) in v.iter().enumerate() {
+    ///     println!("{x}");
     /// }
     /// ```
     /// Use instead:
-    /// ```no_run
-    /// let x = vec![Some(1), Some(2), Some(3)];
-    /// for n in x.into_iter().flatten() {
-    ///     println!("{}", n);
+    /// ```rust
+    /// let v = vec![1, 2, 3, 4];
+    /// for x in v.iter() {
+    ///     println!("{x}");
     /// }
     /// ```
-    #[clippy::version = "1.52.0"]
-    pub MANUAL_FLATTEN,
-    complexity,
-    "for loops over `Option`s or `Result`s with a single expression can be simplified"
+    #[clippy::version = "1.75.0"]
+    pub UNUSED_ENUMERATE_INDEX,
+    style,
+    "using `.enumerate()` and immediately dropping the index"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for empty spin loops
+    /// Checks for while loops comparing floating point values.
     ///
     /// ### Why is this bad?
-    /// The loop body should have something like `thread::park()` or at least
-    /// `std::hint::spin_loop()` to avoid needlessly burning cycles and conserve
-    /// energy. Perhaps even better use an actual lock, if possible.
+    /// If you increment floating point values, errors can compound,
+    /// so, use integers instead if possible.
     ///
     /// ### Known problems
-    /// This lint doesn't currently trigger on `while let` or
-    /// `loop { match .. { .. } }` loops, which would be considered idiomatic in
-    /// combination with e.g. `AtomicBool::compare_exchange_weak`.
-    ///
-    /// ### Example
-    ///
-    /// ```ignore
-    /// use core::sync::atomic::{AtomicBool, Ordering};
-    /// let b = AtomicBool::new(true);
-    /// // give a ref to `b` to another thread,wait for it to become false
-    /// while b.load(Ordering::Acquire) {};
-    /// ```
-    /// Use instead:
-    /// ```rust,no_run
-    ///# use core::sync::atomic::{AtomicBool, Ordering};
-    ///# let b = AtomicBool::new(true);
-    /// while b.load(Ordering::Acquire) {
-    ///     std::hint::spin_loop()
-    /// }
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub MISSING_SPIN_LOOP,
-    perf,
-    "An empty busy waiting loop"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementations of Iterator::find
-    ///
-    /// ### Why is this bad?
-    /// It doesn't affect performance, but using `find` is shorter and easier to read.
+    /// The lint will catch all while loops comparing floating point
+    /// values without regarding the increment.
     ///
     /// ### Example
-    ///
     /// ```no_run
-    /// fn example(arr: Vec<i32>) -> Option<i32> {
-    ///     for el in arr {
-    ///         if el == 1 {
-    ///             return Some(el);
-    ///         }
-    ///     }
-    ///     None
+    /// let mut x = 0.0;
+    /// while x < 42.0 {
+    ///     x += 1.0;
     /// }
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// fn example(arr: Vec<i32>) -> Option<i32> {
-    ///     arr.into_iter().find(|&el| el == 1)
+    /// let mut x = 0;
+    /// while x < 42 {
+    ///     x += 1;
     /// }
     /// ```
-    #[clippy::version = "1.64.0"]
-    pub MANUAL_FIND,
-    complexity,
-    "manual implementation of `Iterator::find`"
+    #[clippy::version = "1.80.0"]
+    pub WHILE_FLOAT,
+    nursery,
+    "while loops comparing floating point values"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for uses of the `enumerate` method where the index is unused (`_`)
+    /// Checks whether variables used within while loop condition
+    /// can be (and are) mutated in the body.
     ///
     /// ### Why is this bad?
-    /// The index from `.enumerate()` is immediately dropped.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let v = vec![1, 2, 3, 4];
-    /// for (_, x) in v.iter().enumerate() {
-    ///     println!("{x}");
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let v = vec![1, 2, 3, 4];
-    /// for x in v.iter() {
-    ///     println!("{x}");
-    /// }
-    /// ```
-    #[clippy::version = "1.75.0"]
-    pub UNUSED_ENUMERATE_INDEX,
-    style,
-    "using `.enumerate()` and immediately dropping the index"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Looks for loops that check for emptiness of a `Vec` in the condition and pop an element
-    /// in the body as a separate operation.
+    /// If the condition is unchanged, entering the body of the loop
+    /// will lead to an infinite loop.
     ///
-    /// ### Why is this bad?
-    /// Such loops can be written in a more idiomatic way by using a while-let loop and directly
-    /// pattern matching on the return value of `Vec::pop()`.
+    /// ### Known problems
+    /// If the `while`-loop is in a closure, the check for mutation of the
+    /// condition variables in the body can cause false negatives. For example when only `Upvar` `a` is
+    /// in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut numbers = vec![1, 2, 3, 4, 5];
-    /// while !numbers.is_empty() {
-    ///     let number = numbers.pop().unwrap();
-    ///     // use `number`
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let mut numbers = vec![1, 2, 3, 4, 5];
-    /// while let Some(number) = numbers.pop() {
-    ///     // use `number`
-    /// }
-    /// ```
-    #[clippy::version = "1.71.0"]
-    pub MANUAL_WHILE_LET_SOME,
-    style,
-    "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for infinite loops in a function where the return type is not `!`
-    /// and lint accordingly.
-    ///
-    /// ### Why restrict this?
-    /// Making the return type `!` serves as documentation that the function does not return.
-    /// If the function is not intended to loop infinitely, then this lint may detect a bug.
-    ///
-    /// ### Example
-    /// ```no_run,ignore
-    /// fn run_forever() {
-    ///     loop {
-    ///         // do something
-    ///     }
-    /// }
-    /// ```
-    /// If infinite loops are as intended:
-    /// ```no_run,ignore
-    /// fn run_forever() -> ! {
-    ///     loop {
-    ///         // do something
-    ///     }
-    /// }
-    /// ```
-    /// Otherwise add a `break` or `return` condition:
-    /// ```no_run,ignore
-    /// fn run_forever() {
-    ///     loop {
-    ///         // do something
-    ///         if condition {
-    ///             break;
-    ///         }
-    ///     }
+    /// let i = 0;
+    /// while i > 10 {
+    ///     println!("let me loop forever!");
     /// }
     /// ```
-    #[clippy::version = "1.76.0"]
-    pub INFINITE_LOOP,
-    restriction,
-    "possibly unintended infinite loop"
+    #[clippy::version = "pre 1.29.0"]
+    pub WHILE_IMMUTABLE_CONDITION,
+    correctness,
+    "variables used within while expression are not mutated in the body"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for manually filling a slice with a value.
+    /// Detects `loop + match` combinations that are easier
+    /// written as a `while let` loop.
     ///
     /// ### Why is this bad?
-    /// Using the `fill` method is more idiomatic and concise.
+    /// The `while let` loop is usually shorter and more
+    /// readable.
     ///
     /// ### Example
-    /// ```no_run
-    /// let mut some_slice = [1, 2, 3, 4, 5];
-    /// for i in 0..some_slice.len() {
-    ///     some_slice[i] = 0;
+    /// ```rust,no_run
+    /// let y = Some(1);
+    /// loop {
+    ///     let x = match y {
+    ///         Some(x) => x,
+    ///         None => break,
+    ///     };
+    ///     // ..
     /// }
     /// ```
     /// Use instead:
-    /// ```no_run
-    /// let mut some_slice = [1, 2, 3, 4, 5];
-    /// some_slice.fill(0);
+    /// ```rust,no_run
+    /// let y = Some(1);
+    /// while let Some(x) = y {
+    ///     // ..
+    /// };
     /// ```
-    #[clippy::version = "1.86.0"]
-    pub MANUAL_SLICE_FILL,
-    style,
-    "manually filling a slice with a value"
+    #[clippy::version = "pre 1.29.0"]
+    pub WHILE_LET_LOOP,
+    complexity,
+    "`loop { if let { ... } else break }`, which can be written as a `while let` loop"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of a character position yielded by `.chars().enumerate()` in a context where a **byte index** is expected,
-    /// such as an argument to a specific `str` method or indexing into a `str` or `String`.
+    /// Checks for `while let` expressions on iterators.
     ///
     /// ### Why is this bad?
-    /// A character (more specifically, a Unicode scalar value) that is yielded by `str::chars` can take up multiple bytes,
-    /// so a character position does not necessarily have the same byte index at which the character is stored.
-    /// Thus, using the character position where a byte index is expected can unexpectedly return wrong values
-    /// or panic when the string consists of multibyte characters.
-    ///
-    /// For example, the character `a` in `äa` is stored at byte index 2 but has the character position 1.
-    /// Using the character position 1 to index into the string will lead to a panic as it is in the middle of the first character.
-    ///
-    /// Instead of `.chars().enumerate()`, the correct iterator to use is `.char_indices()`, which yields byte indices.
-    ///
-    /// This pattern is technically fine if the strings are known to only use the ASCII subset,
-    /// though in those cases it would be better to use `bytes()` directly to make the intent clearer,
-    /// but there is also no downside to just using `.char_indices()` directly and supporting non-ASCII strings.
-    ///
-    /// You may also want to read the [chapter on strings in the Rust Book](https://doc.rust-lang.org/book/ch08-02-strings.html)
-    /// which goes into this in more detail.
+    /// Readability. A simple `for` loop is shorter and conveys
+    /// the intent better.
     ///
     /// ### Example
-    /// ```no_run
-    /// # let s = "...";
-    /// for (idx, c) in s.chars().enumerate() {
-    ///     let _ = s[idx..]; // ⚠️ Panics for strings consisting of multibyte characters
+    /// ```ignore
+    /// while let Some(val) = iter.next() {
+    ///     ..
     /// }
     /// ```
+    ///
     /// Use instead:
-    /// ```no_run
-    /// # let s = "...";
-    /// for (idx, c) in s.char_indices() {
-    ///     let _ = s[idx..];
+    /// ```ignore
+    /// for val in &mut iter {
+    ///     ..
     /// }
     /// ```
-    #[clippy::version = "1.88.0"]
-    pub CHAR_INDICES_AS_BYTE_INDICES,
-    correctness,
-    "using the character position yielded by `.chars().enumerate()` in a context where a byte index is expected"
+    #[clippy::version = "pre 1.29.0"]
+    pub WHILE_LET_ON_ITERATOR,
+    style,
+    "using a `while let` loop instead of a for loop on an iterator"
 }
 
+impl_lint_pass!(Loops => [
+    CHAR_INDICES_AS_BYTE_INDICES,
+    EMPTY_LOOP,
+    EXPLICIT_COUNTER_LOOP,
+    EXPLICIT_INTO_ITER_LOOP,
+    EXPLICIT_ITER_LOOP,
+    FOR_KV_MAP,
+    INFINITE_LOOP,
+    ITER_NEXT_LOOP,
+    MANUAL_FIND,
+    MANUAL_FLATTEN,
+    MANUAL_MEMCPY,
+    MANUAL_SLICE_FILL,
+    MANUAL_WHILE_LET_SOME,
+    MISSING_SPIN_LOOP,
+    MUT_RANGE_BOUND,
+    NEEDLESS_RANGE_LOOP,
+    NEVER_LOOP,
+    SAME_ITEM_PUSH,
+    SINGLE_ELEMENT_LOOP,
+    UNUSED_ENUMERATE_INDEX,
+    WHILE_FLOAT,
+    WHILE_IMMUTABLE_CONDITION,
+    WHILE_LET_LOOP,
+    WHILE_LET_ON_ITERATOR,
+]);
+
 pub struct Loops {
     msrv: Msrv,
     enforce_iter_loop_reborrow: bool,
@@ -798,33 +825,6 @@ impl Loops {
     }
 }
 
-impl_lint_pass!(Loops => [
-    MANUAL_MEMCPY,
-    MANUAL_FLATTEN,
-    NEEDLESS_RANGE_LOOP,
-    EXPLICIT_ITER_LOOP,
-    EXPLICIT_INTO_ITER_LOOP,
-    ITER_NEXT_LOOP,
-    WHILE_LET_LOOP,
-    EXPLICIT_COUNTER_LOOP,
-    EMPTY_LOOP,
-    WHILE_LET_ON_ITERATOR,
-    FOR_KV_MAP,
-    NEVER_LOOP,
-    MUT_RANGE_BOUND,
-    WHILE_IMMUTABLE_CONDITION,
-    WHILE_FLOAT,
-    SAME_ITEM_PUSH,
-    SINGLE_ELEMENT_LOOP,
-    MISSING_SPIN_LOOP,
-    MANUAL_FIND,
-    MANUAL_WHILE_LET_SOME,
-    UNUSED_ENUMERATE_INDEX,
-    INFINITE_LOOP,
-    MANUAL_SLICE_FILL,
-    CHAR_INDICES_AS_BYTE_INDICES,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Loops {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let for_loop = higher::ForLoop::hir(expr);
diff --git a/clippy_lints/src/macro_metavars_in_unsafe.rs b/clippy_lints/src/macro_metavars_in_unsafe.rs
index 69fca3aefcaf..9e23219087ce 100644
--- a/clippy_lints/src/macro_metavars_in_unsafe.rs
+++ b/clippy_lints/src/macro_metavars_in_unsafe.rs
@@ -84,6 +84,7 @@ declare_clippy_lint! {
     suspicious,
     "expanding macro metavariables in an unsafe block"
 }
+
 impl_lint_pass!(ExprMetavarsInUnsafe => [MACRO_METAVARS_IN_UNSAFE]);
 
 #[derive(Clone, Debug)]
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 8989793625aa..0991a72ebc9a 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -44,6 +44,8 @@ declare_clippy_lint! {
     "#[macro_use] is no longer needed"
 }
 
+impl_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
+
 /// `MacroRefData` includes the name of the macro.
 #[derive(Debug, Clone)]
 pub struct MacroRefData {
@@ -66,8 +68,6 @@ pub struct MacroUseImports {
     mac_refs: Vec<MacroRefData>,
 }
 
-impl_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
-
 impl MacroUseImports {
     fn push_unique_macro(&mut self, cx: &LateContext<'_>, span: Span) {
         let call_site = span.source_callsite();
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index 01ea2f5debea..ecdeedc955a9 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -25,13 +25,13 @@ declare_clippy_lint! {
     "recursion using the entrypoint"
 }
 
+impl_lint_pass!(MainRecursion => [MAIN_RECURSION]);
+
 #[derive(Default)]
 pub struct MainRecursion {
     has_no_std_attr: bool,
 }
 
-impl_lint_pass!(MainRecursion => [MAIN_RECURSION]);
-
 impl LateLintPass<'_> for MainRecursion {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         self.has_no_std_attr = is_no_std_crate(cx);
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 40fe88532729..1c686df30e1e 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -34,6 +34,8 @@ declare_clippy_lint! {
     "manual implementation of `size_of::<T>() * 8` can be simplified with `T::BITS`"
 }
 
+impl_lint_pass!(ManualBits => [MANUAL_BITS]);
+
 pub struct ManualBits {
     msrv: Msrv,
 }
@@ -44,8 +46,6 @@ impl ManualBits {
     }
 }
 
-impl_lint_pass!(ManualBits => [MANUAL_BITS]);
-
 impl<'tcx> LateLintPass<'tcx> for ManualBits {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Binary(bin_op, left_expr, right_expr) = expr.kind
diff --git a/clippy_lints/src/manual_checked_ops.rs b/clippy_lints/src/manual_checked_ops.rs
index 6327567df336..5fd1e27d5b99 100644
--- a/clippy_lints/src/manual_checked_ops.rs
+++ b/clippy_lints/src/manual_checked_ops.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     complexity,
     "manual zero checks before dividing integers"
 }
+
 declare_lint_pass!(ManualCheckedOps => [MANUAL_CHECKED_OPS]);
 
 #[derive(Copy, Clone)]
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index 54387e36d6c8..c8fba3e5a7bc 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -88,6 +88,7 @@ declare_clippy_lint! {
     complexity,
     "using a clamp pattern instead of the clamp function"
 }
+
 impl_lint_pass!(ManualClamp => [MANUAL_CLAMP]);
 
 pub struct ManualClamp {
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index a81c4dc6a793..75a3b87f9ce9 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -15,53 +15,55 @@ use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for manual `is_infinite` reimplementations
-    /// (i.e., `x == <float>::INFINITY || x == <float>::NEG_INFINITY`).
+    /// Checks for manual `is_finite` reimplementations
+    /// (i.e., `x != <float>::INFINITY && x != <float>::NEG_INFINITY`).
     ///
     /// ### Why is this bad?
-    /// The method `is_infinite` is shorter and more readable.
+    /// The method `is_finite` is shorter and more readable.
     ///
     /// ### Example
     /// ```no_run
     /// # let x = 1.0f32;
-    /// if x == f32::INFINITY || x == f32::NEG_INFINITY {}
+    /// if x != f32::INFINITY && x != f32::NEG_INFINITY {}
+    /// if x.abs() < f32::INFINITY {}
     /// ```
     /// Use instead:
     /// ```no_run
     /// # let x = 1.0f32;
-    /// if x.is_infinite() {}
+    /// if x.is_finite() {}
+    /// if x.is_finite() {}
     /// ```
     #[clippy::version = "1.73.0"]
-    pub MANUAL_IS_INFINITE,
+    pub MANUAL_IS_FINITE,
     style,
-    "use dedicated method to check if a float is infinite"
+    "use dedicated method to check if a float is finite"
 }
+
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for manual `is_finite` reimplementations
-    /// (i.e., `x != <float>::INFINITY && x != <float>::NEG_INFINITY`).
+    /// Checks for manual `is_infinite` reimplementations
+    /// (i.e., `x == <float>::INFINITY || x == <float>::NEG_INFINITY`).
     ///
     /// ### Why is this bad?
-    /// The method `is_finite` is shorter and more readable.
+    /// The method `is_infinite` is shorter and more readable.
     ///
     /// ### Example
     /// ```no_run
     /// # let x = 1.0f32;
-    /// if x != f32::INFINITY && x != f32::NEG_INFINITY {}
-    /// if x.abs() < f32::INFINITY {}
+    /// if x == f32::INFINITY || x == f32::NEG_INFINITY {}
     /// ```
     /// Use instead:
     /// ```no_run
     /// # let x = 1.0f32;
-    /// if x.is_finite() {}
-    /// if x.is_finite() {}
+    /// if x.is_infinite() {}
     /// ```
     #[clippy::version = "1.73.0"]
-    pub MANUAL_IS_FINITE,
+    pub MANUAL_IS_INFINITE,
     style,
-    "use dedicated method to check if a float is finite"
+    "use dedicated method to check if a float is infinite"
 }
-impl_lint_pass!(ManualFloatMethods => [MANUAL_IS_INFINITE, MANUAL_IS_FINITE]);
+
+impl_lint_pass!(ManualFloatMethods => [MANUAL_IS_FINITE, MANUAL_IS_INFINITE]);
 
 #[derive(Clone, Copy)]
 enum Variant {
diff --git a/clippy_lints/src/manual_hash_one.rs b/clippy_lints/src/manual_hash_one.rs
index ccb8d4272bfa..96d69003934f 100644
--- a/clippy_lints/src/manual_hash_one.rs
+++ b/clippy_lints/src/manual_hash_one.rs
@@ -47,6 +47,8 @@ declare_clippy_lint! {
     "manual implementations of `BuildHasher::hash_one`"
 }
 
+impl_lint_pass!(ManualHashOne => [MANUAL_HASH_ONE]);
+
 pub struct ManualHashOne {
     msrv: Msrv,
 }
@@ -57,8 +59,6 @@ impl ManualHashOne {
     }
 }
 
-impl_lint_pass!(ManualHashOne => [MANUAL_HASH_ONE]);
-
 impl LateLintPass<'_> for ManualHashOne {
     fn check_local(&mut self, cx: &LateContext<'_>, local: &LetStmt<'_>) {
         // `let mut hasher = seg.build_hasher();`
diff --git a/clippy_lints/src/manual_ilog2.rs b/clippy_lints/src/manual_ilog2.rs
index 4b411a60f3bf..7c397bd3f5e8 100644
--- a/clippy_lints/src/manual_ilog2.rs
+++ b/clippy_lints/src/manual_ilog2.rs
@@ -37,6 +37,8 @@ declare_clippy_lint! {
     "manually reimplementing `ilog2`"
 }
 
+impl_lint_pass!(ManualIlog2 => [MANUAL_ILOG2]);
+
 pub struct ManualIlog2 {
     msrv: Msrv,
 }
@@ -47,8 +49,6 @@ impl ManualIlog2 {
     }
 }
 
-impl_lint_pass!(ManualIlog2 => [MANUAL_ILOG2]);
-
 impl LateLintPass<'_> for ManualIlog2 {
     fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         if expr.span.in_external_macro(cx.sess().source_map()) {
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index a0f946d22fa6..b55b3995f732 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -57,6 +57,7 @@ declare_clippy_lint! {
     style,
     "use dedicated method to check ascii range"
 }
+
 impl_lint_pass!(ManualIsAsciiCheck => [MANUAL_IS_ASCII_CHECK]);
 
 pub struct ManualIsAsciiCheck {
diff --git a/clippy_lints/src/manual_is_power_of_two.rs b/clippy_lints/src/manual_is_power_of_two.rs
index 25db719c8214..2ba79113e7bc 100644
--- a/clippy_lints/src/manual_is_power_of_two.rs
+++ b/clippy_lints/src/manual_is_power_of_two.rs
@@ -34,12 +34,12 @@ declare_clippy_lint! {
     "manually reimplementing `is_power_of_two`"
 }
 
+impl_lint_pass!(ManualIsPowerOfTwo => [MANUAL_IS_POWER_OF_TWO]);
+
 pub struct ManualIsPowerOfTwo {
     msrv: Msrv,
 }
 
-impl_lint_pass!(ManualIsPowerOfTwo => [MANUAL_IS_POWER_OF_TWO]);
-
 impl ManualIsPowerOfTwo {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
diff --git a/clippy_lints/src/manual_main_separator_str.rs b/clippy_lints/src/manual_main_separator_str.rs
index e78f6affda2a..d93a1f7d1003 100644
--- a/clippy_lints/src/manual_main_separator_str.rs
+++ b/clippy_lints/src/manual_main_separator_str.rs
@@ -34,6 +34,8 @@ declare_clippy_lint! {
     "`&std::path::MAIN_SEPARATOR.to_string()` can be replaced by `std::path::MAIN_SEPARATOR_STR`"
 }
 
+impl_lint_pass!(ManualMainSeparatorStr => [MANUAL_MAIN_SEPARATOR_STR]);
+
 pub struct ManualMainSeparatorStr {
     msrv: Msrv,
 }
@@ -44,8 +46,6 @@ impl ManualMainSeparatorStr {
     }
 }
 
-impl_lint_pass!(ManualMainSeparatorStr => [MANUAL_MAIN_SEPARATOR_STR]);
-
 impl LateLintPass<'_> for ManualMainSeparatorStr {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         let (target, _) = peel_hir_expr_refs(expr);
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 0d783fde3313..82838ecfc689 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -62,6 +62,8 @@ declare_clippy_lint! {
     "manual implementations of the non-exhaustive pattern can be simplified using #[non_exhaustive]"
 }
 
+impl_lint_pass!(ManualNonExhaustive => [MANUAL_NON_EXHAUSTIVE]);
+
 pub struct ManualNonExhaustive {
     msrv: Msrv,
     constructed_enum_variants: FxHashSet<LocalDefId>,
@@ -78,8 +80,6 @@ impl ManualNonExhaustive {
     }
 }
 
-impl_lint_pass!(ManualNonExhaustive => [MANUAL_NON_EXHAUSTIVE]);
-
 impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustive {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if !cx.effective_visibilities.is_exported(item.owner_id.def_id) || !self.msrv.meets(cx, msrvs::NON_EXHAUSTIVE) {
diff --git a/clippy_lints/src/manual_option_as_slice.rs b/clippy_lints/src/manual_option_as_slice.rs
index cb451d8c0da3..2488873fb789 100644
--- a/clippy_lints/src/manual_option_as_slice.rs
+++ b/clippy_lints/src/manual_option_as_slice.rs
@@ -40,6 +40,8 @@ declare_clippy_lint! {
     "manual `Option::as_slice`"
 }
 
+impl_lint_pass!(ManualOptionAsSlice => [MANUAL_OPTION_AS_SLICE]);
+
 pub struct ManualOptionAsSlice {
     msrv: Msrv,
 }
@@ -50,8 +52,6 @@ impl ManualOptionAsSlice {
     }
 }
 
-impl_lint_pass!(ManualOptionAsSlice => [MANUAL_OPTION_AS_SLICE]);
-
 impl LateLintPass<'_> for ManualOptionAsSlice {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         let span = expr.span;
diff --git a/clippy_lints/src/manual_range_patterns.rs b/clippy_lints/src/manual_range_patterns.rs
index bf4f2bff3195..f60b2a1a6729 100644
--- a/clippy_lints/src/manual_range_patterns.rs
+++ b/clippy_lints/src/manual_range_patterns.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     complexity,
     "manually writing range patterns using a combined OR pattern (`|`)"
 }
+
 declare_lint_pass!(ManualRangePatterns => [MANUAL_RANGE_PATTERNS]);
 
 fn expr_as_i128(expr: &PatExpr<'_>) -> Option<i128> {
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index d993ed48eac4..3ee92dca5303 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -35,6 +35,8 @@ declare_clippy_lint! {
     "manually reimplementing `rem_euclid`"
 }
 
+impl_lint_pass!(ManualRemEuclid => [MANUAL_REM_EUCLID]);
+
 pub struct ManualRemEuclid {
     msrv: Msrv,
 }
@@ -45,8 +47,6 @@ impl ManualRemEuclid {
     }
 }
 
-impl_lint_pass!(ManualRemEuclid => [MANUAL_REM_EUCLID]);
-
 impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // (x % c + c) % c
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 6870c9819fc0..65feb8d336da 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -44,6 +44,8 @@ declare_clippy_lint! {
     "`retain()` is simpler and the same functionalities"
 }
 
+impl_lint_pass!(ManualRetain => [MANUAL_RETAIN]);
+
 pub struct ManualRetain {
     msrv: Msrv,
 }
@@ -54,8 +56,6 @@ impl ManualRetain {
     }
 }
 
-impl_lint_pass!(ManualRetain => [MANUAL_RETAIN]);
-
 impl<'tcx> LateLintPass<'tcx> for ManualRetain {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if let Assign(left_expr, collect_expr, _) = &expr.kind
diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index de12fa29d02c..87078f92541d 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     complexity,
     "manual slice size calculation"
 }
+
 impl_lint_pass!(ManualSliceSizeCalculation => [MANUAL_SLICE_SIZE_CALCULATION]);
 
 pub struct ManualSliceSizeCalculation {
diff --git a/clippy_lints/src/manual_string_new.rs b/clippy_lints/src/manual_string_new.rs
index 9b590e092d05..a3ff19d34316 100644
--- a/clippy_lints/src/manual_string_new.rs
+++ b/clippy_lints/src/manual_string_new.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     pedantic,
     "empty String is being created manually"
 }
+
 declare_lint_pass!(ManualStringNew => [MANUAL_STRING_NEW]);
 
 impl LateLintPass<'_> for ManualStringNew {
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 1cceecf3b61b..6216da20f2e5 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -50,6 +50,8 @@ declare_clippy_lint! {
     "suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing"
 }
 
+impl_lint_pass!(ManualStrip => [MANUAL_STRIP]);
+
 pub struct ManualStrip {
     msrv: Msrv,
 }
@@ -60,8 +62,6 @@ impl ManualStrip {
     }
 }
 
-impl_lint_pass!(ManualStrip => [MANUAL_STRIP]);
-
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum StripKind {
     Prefix,
diff --git a/clippy_lints/src/manual_take.rs b/clippy_lints/src/manual_take.rs
index 8e74d04c4556..a0c701b6c24a 100644
--- a/clippy_lints/src/manual_take.rs
+++ b/clippy_lints/src/manual_take.rs
@@ -38,6 +38,9 @@ declare_clippy_lint! {
     complexity,
     "manual `mem::take` implementation"
 }
+
+impl_lint_pass!(ManualTake => [MANUAL_TAKE]);
+
 pub struct ManualTake {
     msrv: Msrv,
 }
@@ -48,8 +51,6 @@ impl ManualTake {
     }
 }
 
-impl_lint_pass!(ManualTake => [MANUAL_TAKE]);
-
 impl LateLintPass<'_> for ManualTake {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let ExprKind::If(cond, then, Some(otherwise)) = expr.kind
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 6f49c5524118..dc8c06ffd79e 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -37,366 +37,429 @@ use rustc_span::{SpanData, SyntaxContext};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for matches with a single arm where an `if let`
-    /// will usually suffice.
+    /// Finds nested `match` or `if let` expressions where the patterns may be "collapsed" together
+    /// without adding any branches.
     ///
-    /// This intentionally does not lint if there are comments
-    /// inside of the other arm, so as to allow the user to document
-    /// why having another explicit pattern with an empty body is necessary,
-    /// or because the comments need to be preserved for other reasons.
+    /// Note that this lint is not intended to find _all_ cases where nested match patterns can be merged, but only
+    /// cases where merging would most likely make the code more readable.
     ///
     /// ### Why is this bad?
-    /// Just readability – `if let` nests less than a `match`.
+    /// It is unnecessarily verbose and complex.
     ///
     /// ### Example
     /// ```no_run
-    /// # fn bar(stool: &str) {}
-    /// # let x = Some("abc");
-    /// match x {
-    ///     Some(ref foo) => bar(foo),
-    ///     _ => (),
+    /// fn func(opt: Option<Result<u64, String>>) {
+    ///     let n = match opt {
+    ///         Some(n) => match n {
+    ///             Ok(n) => n,
+    ///             _ => return,
+    ///         }
+    ///         None => return,
+    ///     };
     /// }
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # fn bar(stool: &str) {}
-    /// # let x = Some("abc");
-    /// if let Some(ref foo) = x {
-    ///     bar(foo);
+    /// fn func(opt: Option<Result<u64, String>>) {
+    ///     let n = match opt {
+    ///         Some(Ok(n)) => n,
+    ///         _ => return,
+    ///     };
     /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub SINGLE_MATCH,
+    #[clippy::version = "1.50.0"]
+    pub COLLAPSIBLE_MATCH,
     style,
-    "a `match` statement with a single nontrivial arm (i.e., where the other arm is `_ => {}`) instead of `if let`"
+    "Nested `match` or `if let` expressions where the patterns may be \"collapsed\" together."
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for matches with two arms where an `if let else` will
-    /// usually suffice.
+    /// Checks for matches being used to destructure a single-variant enum
+    /// or tuple struct where a `let` will suffice.
     ///
     /// ### Why is this bad?
-    /// Just readability – `if let` nests less than a `match`.
-    ///
-    /// ### Known problems
-    /// Personal style preferences may differ.
+    /// Just readability – `let` doesn't nest, whereas a `match` does.
     ///
     /// ### Example
-    /// Using `match`:
-    ///
     /// ```no_run
-    /// # fn bar(foo: &usize) {}
-    /// # let other_ref: usize = 1;
-    /// # let x: Option<&usize> = Some(&1);
-    /// match x {
-    ///     Some(ref foo) => bar(foo),
-    ///     _ => bar(&other_ref),
+    /// enum Wrapper {
+    ///     Data(i32),
     /// }
-    /// ```
     ///
-    /// Using `if let` with `else`:
+    /// let wrapper = Wrapper::Data(42);
     ///
-    /// ```no_run
-    /// # fn bar(foo: &usize) {}
-    /// # let other_ref: usize = 1;
-    /// # let x: Option<&usize> = Some(&1);
-    /// if let Some(ref foo) = x {
-    ///     bar(foo);
-    /// } else {
-    ///     bar(&other_ref);
-    /// }
+    /// let data = match wrapper {
+    ///     Wrapper::Data(i) => i,
+    /// };
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub SINGLE_MATCH_ELSE,
-    pedantic,
-    "a `match` statement with two arms where the second arm's pattern is a placeholder instead of a specific match pattern"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for matches where all arms match a reference,
-    /// suggesting to remove the reference and deref the matched expression
-    /// instead. It also checks for `if let &foo = bar` blocks.
-    ///
-    /// ### Why is this bad?
-    /// It just makes the code less readable. That reference
-    /// destructuring adds nothing to the code.
     ///
-    /// ### Example
-    /// ```rust,ignore
-    /// match x {
-    ///     &A(ref y) => foo(y),
-    ///     &B => bar(),
-    ///     _ => frob(&x),
+    /// The correct use would be:
+    /// ```no_run
+    /// enum Wrapper {
+    ///     Data(i32),
     /// }
-    /// ```
     ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// match *x {
-    ///     A(ref y) => foo(y),
-    ///     B => bar(),
-    ///     _ => frob(x),
-    /// }
+    /// let wrapper = Wrapper::Data(42);
+    /// let Wrapper::Data(data) = wrapper;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub MATCH_REF_PATS,
+    pub INFALLIBLE_DESTRUCTURING_MATCH,
     style,
-    "a `match` or `if let` with all arms prefixed with `&` instead of deref-ing the match expression"
+    "a `match` statement with a single infallible arm instead of a `let`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for matches where match expression is a `bool`. It
-    /// suggests to replace the expression with an `if...else` block.
+    /// Checks for usage of `match` which could be implemented using `filter`
     ///
     /// ### Why is this bad?
-    /// It makes the code less readable.
+    /// Using the `filter` method is clearer and more concise.
     ///
     /// ### Example
     /// ```no_run
-    /// # fn foo() {}
-    /// # fn bar() {}
-    /// let condition: bool = true;
-    /// match condition {
-    ///     true => foo(),
-    ///     false => bar(),
-    /// }
+    /// match Some(0) {
+    ///     Some(x) => if x % 2 == 0 {
+    ///                     Some(x)
+    ///                } else {
+    ///                     None
+    ///                 },
+    ///     None => None,
+    /// };
     /// ```
-    /// Use if/else instead:
+    /// Use instead:
     /// ```no_run
-    /// # fn foo() {}
-    /// # fn bar() {}
-    /// let condition: bool = true;
-    /// if condition {
-    ///     foo();
-    /// } else {
-    ///     bar();
-    /// }
+    /// Some(0).filter(|&x| x % 2 == 0);
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_BOOL,
-    pedantic,
-    "a `match` on a boolean expression instead of an `if..else` block"
+    #[clippy::version = "1.66.0"]
+    pub MANUAL_FILTER,
+    complexity,
+    "reimplementation of `filter`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for overlapping match arms.
+    /// Checks for usage of `match` which could be implemented using `map`
     ///
     /// ### Why is this bad?
-    /// It is likely to be an error and if not, makes the code
-    /// less obvious.
+    /// Using the `map` method is clearer and more concise.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = 5;
-    /// match x {
-    ///     1..=10 => println!("1 ... 10"),
-    ///     5..=15 => println!("5 ... 15"),
-    ///     _ => (),
-    /// }
+    /// match Some(0) {
+    ///     Some(x) => Some(x + 1),
+    ///     None => None,
+    /// };
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_OVERLAPPING_ARM,
+    /// Use instead:
+    /// ```no_run
+    /// Some(0).map(|x| x + 1);
+    /// ```
+    #[clippy::version = "1.52.0"]
+    pub MANUAL_MAP,
     style,
-    "a `match` with overlapping arms"
+    "reimplementation of `map`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for arm which matches all errors with `Err(_)`
-    /// and take drastic actions like `panic!`.
+    /// Checks for manual implementation of `.ok()` or `.err()`
+    /// on `Result` values.
     ///
     /// ### Why is this bad?
-    /// It is generally a bad practice, similar to
-    /// catching all exceptions in java with `catch(Exception)`
+    /// Using `.ok()` or `.err()` rather than a `match` or
+    /// `if let` is less complex and more readable.
     ///
     /// ### Example
     /// ```no_run
-    /// let x: Result<i32, &str> = Ok(3);
-    /// match x {
-    ///     Ok(_) => println!("ok"),
-    ///     Err(_) => panic!("err"),
-    /// }
+    /// # fn func() -> Result<u32, &'static str> { Ok(0) }
+    /// let a = match func() {
+    ///     Ok(v) => Some(v),
+    ///     Err(_) => None,
+    /// };
+    /// let b = if let Err(v) = func() {
+    ///     Some(v)
+    /// } else {
+    ///     None
+    /// };
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_WILD_ERR_ARM,
-    pedantic,
-    "a `match` with `Err(_)` arm and take drastic actions"
+    /// Use instead:
+    /// ```no_run
+    /// # fn func() -> Result<u32, &'static str> { Ok(0) }
+    /// let a = func().ok();
+    /// let b = func().err();
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub MANUAL_OK_ERR,
+    complexity,
+    "find manual implementations of `.ok()` or `.err()` on `Result`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for match which is used to add a reference to an
-    /// `Option` value.
+    /// Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.
     ///
     /// ### Why is this bad?
-    /// Using `as_ref()` or `as_mut()` instead is shorter.
+    /// Concise code helps focusing on behavior instead of boilerplate.
     ///
     /// ### Example
     /// ```no_run
-    /// let x: Option<()> = None;
-    ///
-    /// let r: Option<&()> = match x {
-    ///     None => None,
-    ///     Some(ref v) => Some(v),
+    /// let foo: Option<i32> = None;
+    /// match foo {
+    ///     Some(v) => v,
+    ///     None => 1,
     /// };
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// let x: Option<()> = None;
-    ///
-    /// let r: Option<&()> = x.as_ref();
+    /// let foo: Option<i32> = None;
+    /// foo.unwrap_or(1);
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_AS_REF,
+    #[clippy::version = "1.49.0"]
+    pub MANUAL_UNWRAP_OR,
     complexity,
-    "a `match` on an Option value instead of using `as_ref()` or `as_mut`"
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or` or `Result::unwrap_or`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for wildcard enum matches using `_`.
-    ///
-    /// ### Why restrict this?
-    /// New enum variants added by library updates can be missed.
+    /// Checks if a `match` or `if let` expression can be simplified using
+    /// `.unwrap_or_default()`.
     ///
-    /// ### Known problems
-    /// Suggested replacements may be incorrect if guards exhaustively cover some
-    /// variants, and also may not use correct path to enum if it's not present in the current scope.
+    /// ### Why is this bad?
+    /// It can be done in one call with `.unwrap_or_default()`.
     ///
     /// ### Example
     /// ```no_run
-    /// # enum Foo { A(usize), B(usize) }
-    /// # let x = Foo::B(1);
-    /// match x {
-    ///     Foo::A(_) => {},
-    ///     _ => {},
-    /// }
+    /// let x: Option<String> = Some(String::new());
+    /// let y: String = match x {
+    ///     Some(v) => v,
+    ///     None => String::new(),
+    /// };
+    ///
+    /// let x: Option<Vec<String>> = Some(Vec::new());
+    /// let y: Vec<String> = if let Some(v) = x {
+    ///     v
+    /// } else {
+    ///     Vec::new()
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x: Option<String> = Some(String::new());
+    /// let y: String = x.unwrap_or_default();
+    ///
+    /// let x: Option<Vec<String>> = Some(Vec::new());
+    /// let y: Vec<String> = x.unwrap_or_default();
+    /// ```
+    #[clippy::version = "1.79.0"]
+    pub MANUAL_UNWRAP_OR_DEFAULT,
+    suspicious,
+    "check if a `match` or `if let` can be simplified with `unwrap_or_default`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for match which is used to add a reference to an
+    /// `Option` value.
+    ///
+    /// ### Why is this bad?
+    /// Using `as_ref()` or `as_mut()` instead is shorter.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: Option<()> = None;
+    ///
+    /// let r: Option<&()> = match x {
+    ///     None => None,
+    ///     Some(ref v) => Some(v),
+    /// };
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # enum Foo { A(usize), B(usize) }
-    /// # let x = Foo::B(1);
-    /// match x {
-    ///     Foo::A(_) => {},
-    ///     Foo::B(_) => {},
+    /// let x: Option<()> = None;
+    ///
+    /// let r: Option<&()> = x.as_ref();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_AS_REF,
+    complexity,
+    "a `match` on an Option value instead of using `as_ref()` or `as_mut`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for matches where match expression is a `bool`. It
+    /// suggests to replace the expression with an `if...else` block.
+    ///
+    /// ### Why is this bad?
+    /// It makes the code less readable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # fn foo() {}
+    /// # fn bar() {}
+    /// let condition: bool = true;
+    /// match condition {
+    ///     true => foo(),
+    ///     false => bar(),
     /// }
     /// ```
-    #[clippy::version = "1.34.0"]
-    pub WILDCARD_ENUM_MATCH_ARM,
-    restriction,
-    "a wildcard enum match arm using `_`"
+    /// Use if/else instead:
+    /// ```no_run
+    /// # fn foo() {}
+    /// # fn bar() {}
+    /// let condition: bool = true;
+    /// if condition {
+    ///     foo();
+    /// } else {
+    ///     bar();
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_BOOL,
+    pedantic,
+    "a `match` on a boolean expression instead of an `if..else` block"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for wildcard enum matches for a single variant.
+    /// Checks for `match`  or `if let` expressions producing a
+    /// `bool` that could be written using `matches!`
     ///
     /// ### Why is this bad?
-    /// New enum variants added by library updates can be missed.
+    /// Readability and needless complexity.
     ///
     /// ### Known problems
-    /// Suggested replacements may not use correct path to enum
-    /// if it's not present in the current scope.
+    /// This lint falsely triggers, if there are arms with
+    /// `cfg` attributes that remove an arm evaluating to `false`.
     ///
     /// ### Example
     /// ```no_run
-    /// # enum Foo { A, B, C }
-    /// # let x = Foo::B;
-    /// match x {
-    ///     Foo::A => {},
-    ///     Foo::B => {},
-    ///     _ => {},
-    /// }
+    /// let x = Some(5);
+    ///
+    /// let a = match x {
+    ///     Some(0) => true,
+    ///     _ => false,
+    /// };
+    ///
+    /// let a = if let Some(0) = x {
+    ///     true
+    /// } else {
+    ///     false
+    /// };
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # enum Foo { A, B, C }
-    /// # let x = Foo::B;
+    /// let x = Some(5);
+    /// let a = matches!(x, Some(0));
+    /// ```
+    #[clippy::version = "1.47.0"]
+    pub MATCH_LIKE_MATCHES_MACRO,
+    style,
+    "a match that could be written with the matches! macro"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for overlapping match arms.
+    ///
+    /// ### Why is this bad?
+    /// It is likely to be an error and if not, makes the code
+    /// less obvious.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = 5;
     /// match x {
-    ///     Foo::A => {},
-    ///     Foo::B => {},
-    ///     Foo::C => {},
+    ///     1..=10 => println!("1 ... 10"),
+    ///     5..=15 => println!("5 ... 15"),
+    ///     _ => (),
     /// }
     /// ```
-    #[clippy::version = "1.45.0"]
-    pub MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-    pedantic,
-    "a wildcard enum match for a single variant"
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_OVERLAPPING_ARM,
+    style,
+    "a `match` with overlapping arms"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for wildcard pattern used with others patterns in same match arm.
+    /// Checks for matches where all arms match a reference,
+    /// suggesting to remove the reference and deref the matched expression
+    /// instead. It also checks for `if let &foo = bar` blocks.
     ///
     /// ### Why is this bad?
-    /// Wildcard pattern already covers any other pattern as it will match anyway.
-    /// It makes the code less readable, especially to spot wildcard pattern use in match arm.
+    /// It just makes the code less readable. That reference
+    /// destructuring adds nothing to the code.
     ///
     /// ### Example
-    /// ```no_run
-    /// # let s = "foo";
-    /// match s {
-    ///     "a" => {},
-    ///     "bar" | _ => {},
+    /// ```rust,ignore
+    /// match x {
+    ///     &A(ref y) => foo(y),
+    ///     &B => bar(),
+    ///     _ => frob(&x),
     /// }
     /// ```
     ///
     /// Use instead:
-    /// ```no_run
-    /// # let s = "foo";
-    /// match s {
-    ///     "a" => {},
-    ///     _ => {},
+    /// ```rust,ignore
+    /// match *x {
+    ///     A(ref y) => foo(y),
+    ///     B => bar(),
+    ///     _ => frob(x),
     /// }
     /// ```
-    #[clippy::version = "1.42.0"]
-    pub WILDCARD_IN_OR_PATTERNS,
-    complexity,
-    "a wildcard pattern used with others patterns in same match arm"
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_REF_PATS,
+    style,
+    "a `match` or `if let` with all arms prefixed with `&` instead of deref-ing the match expression"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for matches being used to destructure a single-variant enum
-    /// or tuple struct where a `let` will suffice.
+    /// Checks for `match` with identical arm bodies.
+    ///
+    /// Note: Does not lint on wildcards if the `non_exhaustive_omitted_patterns_lint` feature is
+    /// enabled and disallowed.
     ///
     /// ### Why is this bad?
-    /// Just readability – `let` doesn't nest, whereas a `match` does.
+    /// This is probably a copy & paste error. If arm bodies
+    /// are the same on purpose, you can factor them
+    /// [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).
     ///
     /// ### Example
-    /// ```no_run
-    /// enum Wrapper {
-    ///     Data(i32),
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar => bar(),
+    ///     Quz => quz(),
+    ///     Baz => bar(), // <= oops
     /// }
-    ///
-    /// let wrapper = Wrapper::Data(42);
-    ///
-    /// let data = match wrapper {
-    ///     Wrapper::Data(i) => i,
-    /// };
     /// ```
     ///
-    /// The correct use would be:
-    /// ```no_run
-    /// enum Wrapper {
-    ///     Data(i32),
+    /// This should probably be
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar => bar(),
+    ///     Quz => quz(),
+    ///     Baz => baz(), // <= fixed
     /// }
+    /// ```
     ///
-    /// let wrapper = Wrapper::Data(42);
-    /// let Wrapper::Data(data) = wrapper;
+    /// or if the original code was not a typo:
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar | Baz => bar(), // <= shows the intent better
+    ///     Quz => quz(),
+    /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub INFALLIBLE_DESTRUCTURING_MATCH,
-    style,
-    "a `match` statement with a single infallible arm instead of a `let`"
+    pub MATCH_SAME_ARMS,
+    pedantic,
+    "`match` with identical arm bodies"
 }
 
 declare_clippy_lint! {
@@ -435,182 +498,94 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.
+    /// Checks for `match` expressions modifying the case of a string with non-compliant arms
     ///
-    /// ### Why restrict this?
-    /// Correctness and readability. It's like having a wildcard pattern after
-    /// matching all enum variants explicitly.
+    /// ### Why is this bad?
+    /// The arm is unreachable, which is likely a mistake
     ///
     /// ### Example
     /// ```no_run
-    /// # struct A { a: i32 }
-    /// let a = A { a: 5 };
-    ///
-    /// match a {
-    ///     A { a: 5, .. } => {},
-    ///     _ => {},
+    /// # let text = "Foo";
+    /// match &*text.to_ascii_lowercase() {
+    ///     "foo" => {},
+    ///     "Bar" => {},
+    ///     _ => {},
     /// }
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # struct A { a: i32 }
-    /// # let a = A { a: 5 };
-    /// match a {
-    ///     A { a: 5 } => {},
+    /// # let text = "Foo";
+    /// match &*text.to_ascii_lowercase() {
+    ///     "foo" => {},
+    ///     "bar" => {},
     ///     _ => {},
     /// }
     /// ```
-    #[clippy::version = "1.43.0"]
-    pub REST_PAT_IN_FULLY_BOUND_STRUCTS,
-    restriction,
-    "a match on a struct that binds all fields but still uses the wildcard pattern"
+    #[clippy::version = "1.58.0"]
+    pub MATCH_STR_CASE_MISMATCH,
+    correctness,
+    "creation of a case altering match expression with non-compliant arms"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Lint for redundant pattern matching over `Result`, `Option`,
-    /// `std::task::Poll`, `std::net::IpAddr` or `bool`s
+    /// Checks for arm which matches all errors with `Err(_)`
+    /// and take drastic actions like `panic!`.
     ///
     /// ### Why is this bad?
-    /// It's more concise and clear to just use the proper
-    /// utility function or using the condition directly
-    ///
-    /// ### Known problems
-    /// For suggestions involving bindings in patterns, this will change the drop order for the matched type.
-    /// Both `if let` and `while let` will drop the value at the end of the block, both `if` and `while` will drop the
-    /// value before entering the block. For most types this change will not matter, but for a few
-    /// types this will not be an acceptable change (e.g. locks). See the
-    /// [reference](https://doc.rust-lang.org/reference/destructors.html#drop-scopes) for more about
-    /// drop order.
+    /// It is generally a bad practice, similar to
+    /// catching all exceptions in java with `catch(Exception)`
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::task::Poll;
-    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-    /// if let Ok(_) = Ok::<i32, i32>(42) {}
-    /// if let Err(_) = Err::<i32, i32>(42) {}
-    /// if let None = None::<()> {}
-    /// if let Some(_) = Some(42) {}
-    /// if let Poll::Pending = Poll::Pending::<()> {}
-    /// if let Poll::Ready(_) = Poll::Ready(42) {}
-    /// if let IpAddr::V4(_) = IpAddr::V4(Ipv4Addr::LOCALHOST) {}
-    /// if let IpAddr::V6(_) = IpAddr::V6(Ipv6Addr::LOCALHOST) {}
-    /// match Ok::<i32, i32>(42) {
-    ///     Ok(_) => true,
-    ///     Err(_) => false,
-    /// };
-    ///
-    /// let cond = true;
-    /// if let true = cond {}
-    /// matches!(cond, true);
-    /// ```
-    ///
-    /// The more idiomatic use would be:
-    ///
-    /// ```no_run
-    /// # use std::task::Poll;
-    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-    /// if Ok::<i32, i32>(42).is_ok() {}
-    /// if Err::<i32, i32>(42).is_err() {}
-    /// if None::<()>.is_none() {}
-    /// if Some(42).is_some() {}
-    /// if Poll::Pending::<()>.is_pending() {}
-    /// if Poll::Ready(42).is_ready() {}
-    /// if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
-    /// if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
-    /// Ok::<i32, i32>(42).is_ok();
-    ///
-    /// let cond = true;
-    /// if cond {}
-    /// cond;
+    /// let x: Result<i32, &str> = Ok(3);
+    /// match x {
+    ///     Ok(_) => println!("ok"),
+    ///     Err(_) => panic!("err"),
+    /// }
     /// ```
-    #[clippy::version = "1.31.0"]
-    pub REDUNDANT_PATTERN_MATCHING,
-    style,
-    "use the proper utility function avoiding an `if let`"
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_WILD_ERR_ARM,
+    pedantic,
+    "a `match` with `Err(_)` arm and take drastic actions"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `match`  or `if let` expressions producing a
-    /// `bool` that could be written using `matches!`
+    /// Checks for wildcard enum matches for a single variant.
     ///
     /// ### Why is this bad?
-    /// Readability and needless complexity.
+    /// New enum variants added by library updates can be missed.
     ///
     /// ### Known problems
-    /// This lint falsely triggers, if there are arms with
-    /// `cfg` attributes that remove an arm evaluating to `false`.
+    /// Suggested replacements may not use correct path to enum
+    /// if it's not present in the current scope.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = Some(5);
-    ///
-    /// let a = match x {
-    ///     Some(0) => true,
-    ///     _ => false,
-    /// };
-    ///
-    /// let a = if let Some(0) = x {
-    ///     true
-    /// } else {
-    ///     false
-    /// };
+    /// # enum Foo { A, B, C }
+    /// # let x = Foo::B;
+    /// match x {
+    ///     Foo::A => {},
+    ///     Foo::B => {},
+    ///     _ => {},
+    /// }
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// let x = Some(5);
-    /// let a = matches!(x, Some(0));
-    /// ```
-    #[clippy::version = "1.47.0"]
-    pub MATCH_LIKE_MATCHES_MACRO,
-    style,
-    "a match that could be written with the matches! macro"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `match` with identical arm bodies.
-    ///
-    /// Note: Does not lint on wildcards if the `non_exhaustive_omitted_patterns_lint` feature is
-    /// enabled and disallowed.
-    ///
-    /// ### Why is this bad?
-    /// This is probably a copy & paste error. If arm bodies
-    /// are the same on purpose, you can factor them
-    /// [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar => bar(),
-    ///     Quz => quz(),
-    ///     Baz => bar(), // <= oops
-    /// }
-    /// ```
-    ///
-    /// This should probably be
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar => bar(),
-    ///     Quz => quz(),
-    ///     Baz => baz(), // <= fixed
-    /// }
-    /// ```
-    ///
-    /// or if the original code was not a typo:
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar | Baz => bar(), // <= shows the intent better
-    ///     Quz => quz(),
+    /// # enum Foo { A, B, C }
+    /// # let x = Foo::B;
+    /// match x {
+    ///     Foo::A => {},
+    ///     Foo::B => {},
+    ///     Foo::C => {},
     /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_SAME_ARMS,
+    #[clippy::version = "1.45.0"]
+    pub MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
     pedantic,
-    "`match` with identical arm bodies"
+    "a wildcard enum match for a single variant"
 }
 
 declare_clippy_lint! {
@@ -658,135 +633,130 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds nested `match` or `if let` expressions where the patterns may be "collapsed" together
-    /// without adding any branches.
-    ///
-    /// Note that this lint is not intended to find _all_ cases where nested match patterns can be merged, but only
-    /// cases where merging would most likely make the code more readable.
+    /// Checks for unnecessary guards in match expressions.
     ///
     /// ### Why is this bad?
-    /// It is unnecessarily verbose and complex.
+    /// It's more complex and much less readable. Making it part of the pattern can improve
+    /// exhaustiveness checking as well.
     ///
     /// ### Example
-    /// ```no_run
-    /// fn func(opt: Option<Result<u64, String>>) {
-    ///     let n = match opt {
-    ///         Some(n) => match n {
-    ///             Ok(n) => n,
-    ///             _ => return,
-    ///         }
-    ///         None => return,
-    ///     };
+    /// ```rust,ignore
+    /// match x {
+    ///     Some(x) if matches!(x, Some(1)) => ..,
+    ///     Some(x) if x == Some(2) => ..,
+    ///     _ => todo!(),
     /// }
     /// ```
     /// Use instead:
-    /// ```no_run
-    /// fn func(opt: Option<Result<u64, String>>) {
-    ///     let n = match opt {
-    ///         Some(Ok(n)) => n,
-    ///         _ => return,
-    ///     };
+    /// ```rust,ignore
+    /// match x {
+    ///     Some(Some(1)) => ..,
+    ///     Some(Some(2)) => ..,
+    ///     _ => todo!(),
     /// }
     /// ```
-    #[clippy::version = "1.50.0"]
-    pub COLLAPSIBLE_MATCH,
-    style,
-    "Nested `match` or `if let` expressions where the patterns may be \"collapsed\" together."
+    #[clippy::version = "1.73.0"]
+    pub REDUNDANT_GUARDS,
+    complexity,
+    "checks for unnecessary guards in match expressions"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.
+    /// Lint for redundant pattern matching over `Result`, `Option`,
+    /// `std::task::Poll`, `std::net::IpAddr` or `bool`s
     ///
     /// ### Why is this bad?
-    /// Concise code helps focusing on behavior instead of boilerplate.
+    /// It's more concise and clear to just use the proper
+    /// utility function or using the condition directly
+    ///
+    /// ### Known problems
+    /// For suggestions involving bindings in patterns, this will change the drop order for the matched type.
+    /// Both `if let` and `while let` will drop the value at the end of the block, both `if` and `while` will drop the
+    /// value before entering the block. For most types this change will not matter, but for a few
+    /// types this will not be an acceptable change (e.g. locks). See the
+    /// [reference](https://doc.rust-lang.org/reference/destructors.html#drop-scopes) for more about
+    /// drop order.
     ///
     /// ### Example
     /// ```no_run
-    /// let foo: Option<i32> = None;
-    /// match foo {
-    ///     Some(v) => v,
-    ///     None => 1,
+    /// # use std::task::Poll;
+    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+    /// if let Ok(_) = Ok::<i32, i32>(42) {}
+    /// if let Err(_) = Err::<i32, i32>(42) {}
+    /// if let None = None::<()> {}
+    /// if let Some(_) = Some(42) {}
+    /// if let Poll::Pending = Poll::Pending::<()> {}
+    /// if let Poll::Ready(_) = Poll::Ready(42) {}
+    /// if let IpAddr::V4(_) = IpAddr::V4(Ipv4Addr::LOCALHOST) {}
+    /// if let IpAddr::V6(_) = IpAddr::V6(Ipv6Addr::LOCALHOST) {}
+    /// match Ok::<i32, i32>(42) {
+    ///     Ok(_) => true,
+    ///     Err(_) => false,
     /// };
+    ///
+    /// let cond = true;
+    /// if let true = cond {}
+    /// matches!(cond, true);
     /// ```
     ///
-    /// Use instead:
+    /// The more idiomatic use would be:
+    ///
     /// ```no_run
-    /// let foo: Option<i32> = None;
-    /// foo.unwrap_or(1);
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub MANUAL_UNWRAP_OR,
-    complexity,
-    "finds patterns that can be encoded more concisely with `Option::unwrap_or` or `Result::unwrap_or`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks if a `match` or `if let` expression can be simplified using
-    /// `.unwrap_or_default()`.
-    ///
-    /// ### Why is this bad?
-    /// It can be done in one call with `.unwrap_or_default()`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x: Option<String> = Some(String::new());
-    /// let y: String = match x {
-    ///     Some(v) => v,
-    ///     None => String::new(),
-    /// };
-    ///
-    /// let x: Option<Vec<String>> = Some(Vec::new());
-    /// let y: Vec<String> = if let Some(v) = x {
-    ///     v
-    /// } else {
-    ///     Vec::new()
-    /// };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let x: Option<String> = Some(String::new());
-    /// let y: String = x.unwrap_or_default();
+    /// # use std::task::Poll;
+    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+    /// if Ok::<i32, i32>(42).is_ok() {}
+    /// if Err::<i32, i32>(42).is_err() {}
+    /// if None::<()>.is_none() {}
+    /// if Some(42).is_some() {}
+    /// if Poll::Pending::<()>.is_pending() {}
+    /// if Poll::Ready(42).is_ready() {}
+    /// if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+    /// if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+    /// Ok::<i32, i32>(42).is_ok();
     ///
-    /// let x: Option<Vec<String>> = Some(Vec::new());
-    /// let y: Vec<String> = x.unwrap_or_default();
+    /// let cond = true;
+    /// if cond {}
+    /// cond;
     /// ```
-    #[clippy::version = "1.79.0"]
-    pub MANUAL_UNWRAP_OR_DEFAULT,
-    suspicious,
-    "check if a `match` or `if let` can be simplified with `unwrap_or_default`"
+    #[clippy::version = "1.31.0"]
+    pub REDUNDANT_PATTERN_MATCHING,
+    style,
+    "use the proper utility function avoiding an `if let`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `match` expressions modifying the case of a string with non-compliant arms
+    /// Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.
     ///
-    /// ### Why is this bad?
-    /// The arm is unreachable, which is likely a mistake
+    /// ### Why restrict this?
+    /// Correctness and readability. It's like having a wildcard pattern after
+    /// matching all enum variants explicitly.
     ///
     /// ### Example
     /// ```no_run
-    /// # let text = "Foo";
-    /// match &*text.to_ascii_lowercase() {
-    ///     "foo" => {},
-    ///     "Bar" => {},
+    /// # struct A { a: i32 }
+    /// let a = A { a: 5 };
+    ///
+    /// match a {
+    ///     A { a: 5, .. } => {},
     ///     _ => {},
     /// }
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// # let text = "Foo";
-    /// match &*text.to_ascii_lowercase() {
-    ///     "foo" => {},
-    ///     "bar" => {},
+    /// # struct A { a: i32 }
+    /// # let a = A { a: 5 };
+    /// match a {
+    ///     A { a: 5 } => {},
     ///     _ => {},
     /// }
     /// ```
-    #[clippy::version = "1.58.0"]
-    pub MATCH_STR_CASE_MISMATCH,
-    correctness,
-    "creation of a case altering match expression with non-compliant arms"
+    #[clippy::version = "1.43.0"]
+    pub REST_PAT_IN_FULLY_BOUND_STRUCTS,
+    restriction,
+    "a match on a struct that binds all fields but still uses the wildcard pattern"
 }
 
 declare_clippy_lint! {
@@ -857,155 +827,215 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `Err(x)?`.
+    /// Checks for matches with a single arm where an `if let`
+    /// will usually suffice.
     ///
-    /// ### Why restrict this?
-    /// The `?` operator is designed to allow calls that
-    /// can fail to be easily chained. For example, `foo()?.bar()` or
-    /// `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will
-    /// always return), it is more clear to write `return Err(x)`.
+    /// This intentionally does not lint if there are comments
+    /// inside of the other arm, so as to allow the user to document
+    /// why having another explicit pattern with an empty body is necessary,
+    /// or because the comments need to be preserved for other reasons.
+    ///
+    /// ### Why is this bad?
+    /// Just readability – `if let` nests less than a `match`.
     ///
     /// ### Example
     /// ```no_run
-    /// fn foo(fail: bool) -> Result<i32, String> {
-    ///     if fail {
-    ///       Err("failed")?;
-    ///     }
-    ///     Ok(0)
+    /// # fn bar(stool: &str) {}
+    /// # let x = Some("abc");
+    /// match x {
+    ///     Some(ref foo) => bar(foo),
+    ///     _ => (),
     /// }
     /// ```
-    /// Could be written:
     ///
+    /// Use instead:
     /// ```no_run
-    /// fn foo(fail: bool) -> Result<i32, String> {
-    ///     if fail {
-    ///       return Err("failed".into());
-    ///     }
-    ///     Ok(0)
+    /// # fn bar(stool: &str) {}
+    /// # let x = Some("abc");
+    /// if let Some(ref foo) = x {
+    ///     bar(foo);
     /// }
     /// ```
-    #[clippy::version = "1.38.0"]
-    pub TRY_ERR,
-    restriction,
-    "return errors explicitly rather than hiding them behind a `?`"
+    #[clippy::version = "pre 1.29.0"]
+    pub SINGLE_MATCH,
+    style,
+    "a `match` statement with a single nontrivial arm (i.e., where the other arm is `_ => {}`) instead of `if let`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `match` which could be implemented using `map`
+    /// Checks for matches with two arms where an `if let else` will
+    /// usually suffice.
     ///
     /// ### Why is this bad?
-    /// Using the `map` method is clearer and more concise.
+    /// Just readability – `if let` nests less than a `match`.
+    ///
+    /// ### Known problems
+    /// Personal style preferences may differ.
     ///
     /// ### Example
+    /// Using `match`:
+    ///
     /// ```no_run
-    /// match Some(0) {
-    ///     Some(x) => Some(x + 1),
-    ///     None => None,
-    /// };
+    /// # fn bar(foo: &usize) {}
+    /// # let other_ref: usize = 1;
+    /// # let x: Option<&usize> = Some(&1);
+    /// match x {
+    ///     Some(ref foo) => bar(foo),
+    ///     _ => bar(&other_ref),
+    /// }
     /// ```
-    /// Use instead:
+    ///
+    /// Using `if let` with `else`:
+    ///
     /// ```no_run
-    /// Some(0).map(|x| x + 1);
+    /// # fn bar(foo: &usize) {}
+    /// # let other_ref: usize = 1;
+    /// # let x: Option<&usize> = Some(&1);
+    /// if let Some(ref foo) = x {
+    ///     bar(foo);
+    /// } else {
+    ///     bar(&other_ref);
+    /// }
     /// ```
-    #[clippy::version = "1.52.0"]
-    pub MANUAL_MAP,
-    style,
-    "reimplementation of `map`"
+    #[clippy::version = "pre 1.29.0"]
+    pub SINGLE_MATCH_ELSE,
+    pedantic,
+    "a `match` statement with two arms where the second arm's pattern is a placeholder instead of a specific match pattern"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `match` which could be implemented using `filter`
+    /// Checks for usage of `Err(x)?`.
     ///
-    /// ### Why is this bad?
-    /// Using the `filter` method is clearer and more concise.
+    /// ### Why restrict this?
+    /// The `?` operator is designed to allow calls that
+    /// can fail to be easily chained. For example, `foo()?.bar()` or
+    /// `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will
+    /// always return), it is more clear to write `return Err(x)`.
     ///
     /// ### Example
     /// ```no_run
-    /// match Some(0) {
-    ///     Some(x) => if x % 2 == 0 {
-    ///                     Some(x)
-    ///                } else {
-    ///                     None
-    ///                 },
-    ///     None => None,
-    /// };
+    /// fn foo(fail: bool) -> Result<i32, String> {
+    ///     if fail {
+    ///       Err("failed")?;
+    ///     }
+    ///     Ok(0)
+    /// }
     /// ```
-    /// Use instead:
+    /// Could be written:
+    ///
     /// ```no_run
-    /// Some(0).filter(|&x| x % 2 == 0);
+    /// fn foo(fail: bool) -> Result<i32, String> {
+    ///     if fail {
+    ///       return Err("failed".into());
+    ///     }
+    ///     Ok(0)
+    /// }
     /// ```
-    #[clippy::version = "1.66.0"]
-    pub MANUAL_FILTER,
-    complexity,
-    "reimplementation of `filter`"
+    #[clippy::version = "1.38.0"]
+    pub TRY_ERR,
+    restriction,
+    "return errors explicitly rather than hiding them behind a `?`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for unnecessary guards in match expressions.
+    /// Checks for wildcard enum matches using `_`.
     ///
-    /// ### Why is this bad?
-    /// It's more complex and much less readable. Making it part of the pattern can improve
-    /// exhaustiveness checking as well.
+    /// ### Why restrict this?
+    /// New enum variants added by library updates can be missed.
+    ///
+    /// ### Known problems
+    /// Suggested replacements may be incorrect if guards exhaustively cover some
+    /// variants, and also may not use correct path to enum if it's not present in the current scope.
     ///
     /// ### Example
-    /// ```rust,ignore
+    /// ```no_run
+    /// # enum Foo { A(usize), B(usize) }
+    /// # let x = Foo::B(1);
     /// match x {
-    ///     Some(x) if matches!(x, Some(1)) => ..,
-    ///     Some(x) if x == Some(2) => ..,
-    ///     _ => todo!(),
+    ///     Foo::A(_) => {},
+    ///     _ => {},
     /// }
     /// ```
+    ///
     /// Use instead:
-    /// ```rust,ignore
+    /// ```no_run
+    /// # enum Foo { A(usize), B(usize) }
+    /// # let x = Foo::B(1);
     /// match x {
-    ///     Some(Some(1)) => ..,
-    ///     Some(Some(2)) => ..,
-    ///     _ => todo!(),
+    ///     Foo::A(_) => {},
+    ///     Foo::B(_) => {},
     /// }
     /// ```
-    #[clippy::version = "1.73.0"]
-    pub REDUNDANT_GUARDS,
-    complexity,
-    "checks for unnecessary guards in match expressions"
+    #[clippy::version = "1.34.0"]
+    pub WILDCARD_ENUM_MATCH_ARM,
+    restriction,
+    "a wildcard enum match arm using `_`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for manual implementation of `.ok()` or `.err()`
-    /// on `Result` values.
+    /// Checks for wildcard pattern used with others patterns in same match arm.
     ///
     /// ### Why is this bad?
-    /// Using `.ok()` or `.err()` rather than a `match` or
-    /// `if let` is less complex and more readable.
+    /// Wildcard pattern already covers any other pattern as it will match anyway.
+    /// It makes the code less readable, especially to spot wildcard pattern use in match arm.
     ///
     /// ### Example
     /// ```no_run
-    /// # fn func() -> Result<u32, &'static str> { Ok(0) }
-    /// let a = match func() {
-    ///     Ok(v) => Some(v),
-    ///     Err(_) => None,
-    /// };
-    /// let b = if let Err(v) = func() {
-    ///     Some(v)
-    /// } else {
-    ///     None
-    /// };
+    /// # let s = "foo";
+    /// match s {
+    ///     "a" => {},
+    ///     "bar" | _ => {},
+    /// }
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// # fn func() -> Result<u32, &'static str> { Ok(0) }
-    /// let a = func().ok();
-    /// let b = func().err();
+    /// # let s = "foo";
+    /// match s {
+    ///     "a" => {},
+    ///     _ => {},
+    /// }
     /// ```
-    #[clippy::version = "1.86.0"]
-    pub MANUAL_OK_ERR,
+    #[clippy::version = "1.42.0"]
+    pub WILDCARD_IN_OR_PATTERNS,
     complexity,
-    "find manual implementations of `.ok()` or `.err()` on `Result`"
+    "a wildcard pattern used with others patterns in same match arm"
 }
 
+impl_lint_pass!(Matches => [
+    COLLAPSIBLE_MATCH,
+    INFALLIBLE_DESTRUCTURING_MATCH,
+    MANUAL_FILTER,
+    MANUAL_MAP,
+    MANUAL_OK_ERR,
+    MANUAL_UNWRAP_OR,
+    MANUAL_UNWRAP_OR_DEFAULT,
+    MATCH_AS_REF,
+    MATCH_BOOL,
+    MATCH_LIKE_MATCHES_MACRO,
+    MATCH_OVERLAPPING_ARM,
+    MATCH_REF_PATS,
+    MATCH_SAME_ARMS,
+    MATCH_SINGLE_BINDING,
+    MATCH_STR_CASE_MISMATCH,
+    MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+    MATCH_WILD_ERR_ARM,
+    NEEDLESS_MATCH,
+    REDUNDANT_GUARDS,
+    REDUNDANT_PATTERN_MATCHING,
+    REST_PAT_IN_FULLY_BOUND_STRUCTS,
+    SIGNIFICANT_DROP_IN_SCRUTINEE,
+    SINGLE_MATCH,
+    SINGLE_MATCH_ELSE,
+    TRY_ERR,
+    WILDCARD_ENUM_MATCH_ARM,
+    WILDCARD_IN_OR_PATTERNS,
+]);
+
 pub struct Matches {
     msrv: Msrv,
     infallible_destructuring_match_linted: bool,
@@ -1020,36 +1050,6 @@ impl Matches {
     }
 }
 
-impl_lint_pass!(Matches => [
-    SINGLE_MATCH,
-    MATCH_REF_PATS,
-    MATCH_BOOL,
-    SINGLE_MATCH_ELSE,
-    MATCH_OVERLAPPING_ARM,
-    MATCH_WILD_ERR_ARM,
-    MATCH_AS_REF,
-    WILDCARD_ENUM_MATCH_ARM,
-    MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-    WILDCARD_IN_OR_PATTERNS,
-    MATCH_SINGLE_BINDING,
-    INFALLIBLE_DESTRUCTURING_MATCH,
-    REST_PAT_IN_FULLY_BOUND_STRUCTS,
-    REDUNDANT_PATTERN_MATCHING,
-    MATCH_LIKE_MATCHES_MACRO,
-    MATCH_SAME_ARMS,
-    NEEDLESS_MATCH,
-    COLLAPSIBLE_MATCH,
-    MANUAL_UNWRAP_OR,
-    MANUAL_UNWRAP_OR_DEFAULT,
-    MATCH_STR_CASE_MISMATCH,
-    SIGNIFICANT_DROP_IN_SCRUTINEE,
-    TRY_ERR,
-    MANUAL_MAP,
-    MANUAL_FILTER,
-    REDUNDANT_GUARDS,
-    MANUAL_OK_ERR,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Matches {
     #[expect(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 0f32f89666a0..4f32f35058e5 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -68,6 +68,31 @@ declare_clippy_lint! {
     "replacing an `Option` with `Some` instead of `replace()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `std::mem::replace` on a value of type
+    /// `T` with `T::default()`.
+    ///
+    /// ### Why is this bad?
+    /// `std::mem` module already has the method `take` to
+    /// take the current value and replace it with the default value of that type.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let mut text = String::from("foo");
+    /// let replaced = std::mem::replace(&mut text, String::default());
+    /// ```
+    /// Is better expressed with:
+    /// ```no_run
+    /// let mut text = String::from("foo");
+    /// let taken = std::mem::take(&mut text);
+    /// ```
+    #[clippy::version = "1.42.0"]
+    pub MEM_REPLACE_WITH_DEFAULT,
+    style,
+    "replacing a value of type `T` with `T::default()` instead of using `std::mem::take`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `mem::replace(&mut _, mem::uninitialized())`
@@ -100,33 +125,12 @@ declare_clippy_lint! {
     "`mem::replace(&mut _, mem::uninitialized())` or `mem::replace(&mut _, mem::zeroed())`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `std::mem::replace` on a value of type
-    /// `T` with `T::default()`.
-    ///
-    /// ### Why is this bad?
-    /// `std::mem` module already has the method `take` to
-    /// take the current value and replace it with the default value of that type.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let mut text = String::from("foo");
-    /// let replaced = std::mem::replace(&mut text, String::default());
-    /// ```
-    /// Is better expressed with:
-    /// ```no_run
-    /// let mut text = String::from("foo");
-    /// let taken = std::mem::take(&mut text);
-    /// ```
-    #[clippy::version = "1.42.0"]
-    pub MEM_REPLACE_WITH_DEFAULT,
-    style,
-    "replacing a value of type `T` with `T::default()` instead of using `std::mem::take`"
-}
-
-impl_lint_pass!(MemReplace =>
-    [MEM_REPLACE_OPTION_WITH_NONE, MEM_REPLACE_OPTION_WITH_SOME, MEM_REPLACE_WITH_UNINIT, MEM_REPLACE_WITH_DEFAULT]);
+impl_lint_pass!(MemReplace => [
+    MEM_REPLACE_OPTION_WITH_NONE,
+    MEM_REPLACE_OPTION_WITH_SOME,
+    MEM_REPLACE_WITH_DEFAULT,
+    MEM_REPLACE_WITH_UNINIT,
+]);
 
 fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) -> bool {
     if is_none_expr(cx, src) {
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 74db7ae03ba0..c9fa05a65148 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -165,655 +165,595 @@ use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `cloned()` on an `Iterator` or `Option` where
-    /// `copied()` could be used instead.
+    /// Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))`
+    /// or `_.or_else(|x| Err(y))`.
     ///
     /// ### Why is this bad?
-    /// `copied()` is better because it guarantees that the type being cloned
-    /// implements `Copy`.
+    /// This can be written more concisely as `_.map(|x| y)` or `_.map_err(|x| y)`.
     ///
     /// ### Example
     /// ```no_run
-    /// [1, 2, 3].iter().cloned();
+    /// # fn opt() -> Option<&'static str> { Some("42") }
+    /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
+    /// let _ = opt().and_then(|s| Some(s.len()));
+    /// let _ = res().and_then(|s| if s.len() == 42 { Ok(10) } else { Ok(20) });
+    /// let _ = res().or_else(|s| if s.len() == 42 { Err(10) } else { Err(20) });
     /// ```
-    /// Use instead:
+    ///
+    /// The correct use would be:
+    ///
     /// ```no_run
-    /// [1, 2, 3].iter().copied();
+    /// # fn opt() -> Option<&'static str> { Some("42") }
+    /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
+    /// let _ = opt().map(|s| s.len());
+    /// let _ = res().map(|s| if s.len() == 42 { 10 } else { 20 });
+    /// let _ = res().map_err(|s| if s.len() == 42 { 10 } else { 20 });
     /// ```
-    #[clippy::version = "1.53.0"]
-    pub CLONED_INSTEAD_OF_COPIED,
-    pedantic,
-    "used `cloned` where `copied` could be used instead"
+    #[clippy::version = "1.45.0"]
+    pub BIND_INSTEAD_OF_MAP,
+    complexity,
+    "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for consecutive calls to `str::replace` (2 or more)
-    /// that can be collapsed into a single call.
+    /// It checks for `str::bytes().count()` and suggests replacing it with
+    /// `str::len()`.
     ///
     /// ### Why is this bad?
-    /// Consecutive `str::replace` calls scan the string multiple times
-    /// with repetitive code.
+    /// `str::bytes().count()` is longer and may not be as performant as using
+    /// `str::len()`.
     ///
     /// ### Example
     /// ```no_run
-    /// let hello = "hesuo worpd"
-    ///     .replace('s', "l")
-    ///     .replace("u", "l")
-    ///     .replace('p', "l");
+    /// "hello".bytes().count();
+    /// String::from("hello").bytes().count();
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let hello = "hesuo worpd".replace(['s', 'u', 'p'], "l");
+    /// "hello".len();
+    /// String::from("hello").len();
     /// ```
-    #[clippy::version = "1.65.0"]
-    pub COLLAPSIBLE_STR_REPLACE,
-    perf,
-    "collapse consecutive calls to str::replace (2 or more) into a single call"
+    #[clippy::version = "1.62.0"]
+    pub BYTES_COUNT_TO_LEN,
+    complexity,
+    "Using `bytes().count()` when `len()` performs the same functionality"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.cloned().<func>()` where call to `.cloned()` can be postponed.
+    /// Checks for the use of `.bytes().nth()`.
     ///
     /// ### Why is this bad?
-    /// It's often inefficient to clone all elements of an iterator, when eventually, only some
-    /// of them will be consumed.
-    ///
-    /// ### Known Problems
-    /// This `lint` removes the side of effect of cloning items in the iterator.
-    /// A code that relies on that side-effect could fail.
+    /// `.as_bytes().get()` is more efficient and more
+    /// readable.
     ///
-    /// ### Examples
+    /// ### Example
     /// ```no_run
-    /// # let vec = vec!["string".to_string()];
-    /// vec.iter().cloned().take(10);
-    /// vec.iter().cloned().last();
+    /// "Hello".bytes().nth(3);
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # let vec = vec!["string".to_string()];
-    /// vec.iter().take(10).cloned();
-    /// vec.iter().last().cloned();
+    /// "Hello".as_bytes().get(3);
     /// ```
-    #[clippy::version = "1.60.0"]
-    pub ITER_OVEREAGER_CLONED,
-    perf,
-    "using `cloned()` early with `Iterator::iter()` can lead to some performance inefficiencies"
+    #[clippy::version = "1.52.0"]
+    pub BYTES_NTH,
+    style,
+    "replace `.bytes().nth()` with `.as_bytes().get()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `Iterator::flat_map()` where `filter_map()` could be
-    /// used instead.
+    /// Checks for calls to `ends_with` with possible file extensions
+    /// and suggests to use a case-insensitive approach instead.
     ///
     /// ### Why is this bad?
-    /// `filter_map()` is known to always produce 0 or 1 output items per input item,
-    /// rather than however many the inner iterator type produces.
-    /// Therefore, it maintains the upper bound in `Iterator::size_hint()`,
-    /// and communicates to the reader that the input items are not being expanded into
-    /// multiple output items without their having to notice that the mapping function
-    /// returns an `Option`.
+    /// `ends_with` is case-sensitive and may not detect files with a valid extension.
     ///
     /// ### Example
     /// ```no_run
-    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().flat_map(|x| x.parse().ok()).collect();
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     filename.ends_with(".rs")
+    /// }
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().filter_map(|x| x.parse().ok()).collect();
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     let filename = std::path::Path::new(filename);
+    ///     filename.extension()
+    ///         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
+    /// }
     /// ```
-    #[clippy::version = "1.53.0"]
-    pub FLAT_MAP_OPTION,
+    #[clippy::version = "1.51.0"]
+    pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     pedantic,
-    "used `flat_map` where `filter_map` could be used instead"
+    "Checks for calls to ends_with with case-sensitive file extensions"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `.unwrap()` or `.unwrap_err()` calls on `Result`s and `.unwrap()` call on `Option`s.
-    ///
-    /// ### Why restrict this?
-    /// It is better to handle the `None` or `Err` case,
-    /// or at least call `.expect(_)` with a more helpful message. Still, for a lot of
-    /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
-    /// `Allow` by default.
-    ///
-    /// `result.unwrap()` will let the thread panic on `Err` values.
-    /// Normally, you want to implement more sophisticated error handling,
-    /// and propagate errors upwards with `?` operator.
+    /// Checks for usage of `_.chars().last()` or
+    /// `_.chars().next_back()` on a `str` to check if it ends with a given char.
     ///
-    /// Even if you want to panic on errors, not all `Error`s implement good
-    /// messages on display. Therefore, it may be beneficial to look at the places
-    /// where they may get displayed. Activate this lint to do just that.
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.ends_with(_)`.
     ///
-    /// ### Examples
+    /// ### Example
     /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.unwrap();
-    /// result.unwrap();
+    /// # let name = "_";
+    /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-');
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.expect("more helpful message");
-    /// result.expect("more helpful message");
-    /// ```
-    ///
-    /// If [expect_used](#expect_used) is enabled, instead:
-    /// ```rust,ignore
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option?;
-    ///
-    /// // or
-    ///
-    /// result?;
+    /// # let name = "_";
+    /// name.ends_with('_') || name.ends_with('-');
     /// ```
-    #[clippy::version = "1.45.0"]
-    pub UNWRAP_USED,
-    restriction,
-    "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`"
+    #[clippy::version = "pre 1.29.0"]
+    pub CHARS_LAST_CMP,
+    style,
+    "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `.unwrap()` related calls on `Result`s and `Option`s that are constructed.
+    /// Checks for usage of `.chars().next()` on a `str` to check
+    /// if it starts with a given char.
     ///
     /// ### Why is this bad?
-    /// It is better to write the value directly without the indirection.
+    /// Readability, this can be written more concisely as
+    /// `_.starts_with(_)`.
     ///
-    /// ### Examples
+    /// ### Example
     /// ```no_run
-    /// let val1 = Some(1).unwrap();
-    /// let val2 = Ok::<_, ()>(1).unwrap();
-    /// let val3 = Err::<(), _>(1).unwrap_err();
+    /// let name = "foo";
+    /// if name.chars().next() == Some('_') {};
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// let val1 = 1;
-    /// let val2 = 1;
-    /// let val3 = 1;
+    /// let name = "foo";
+    /// if name.starts_with('_') {};
     /// ```
-    #[clippy::version = "1.72.0"]
-    pub UNNECESSARY_LITERAL_UNWRAP,
-    complexity,
-    "using `unwrap()` related calls on `Result` and `Option` constructors"
+    #[clippy::version = "pre 1.29.0"]
+    pub CHARS_NEXT_CMP,
+    style,
+    "using `.chars().next()` to check if a string starts with a char"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `.expect()` or `.expect_err()` calls on `Result`s and `.expect()` call on `Option`s.
+    /// Checks for usage of `.drain(..)` for the sole purpose of clearing a container.
     ///
-    /// ### Why restrict this?
-    /// Usually it is better to handle the `None` or `Err` case.
-    /// Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why
-    /// this lint is `Allow` by default.
+    /// ### Why is this bad?
+    /// This creates an unnecessary iterator that is dropped immediately.
     ///
-    /// `result.expect()` will let the thread panic on `Err`
-    /// values. Normally, you want to implement more sophisticated error handling,
-    /// and propagate errors upwards with `?` operator.
+    /// Calling `.clear()` also makes the intent clearer.
     ///
-    /// ### Examples
-    /// ```rust,ignore
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.expect("one");
-    /// result.expect("one");
+    /// ### Example
+    /// ```no_run
+    /// let mut v = vec![1, 2, 3];
+    /// v.drain(..);
     /// ```
-    ///
     /// Use instead:
-    /// ```rust,ignore
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option?;
-    ///
-    /// // or
-    ///
-    /// result?;
+    /// ```no_run
+    /// let mut v = vec![1, 2, 3];
+    /// v.clear();
     /// ```
-    #[clippy::version = "1.45.0"]
-    pub EXPECT_USED,
-    restriction,
-    "using `.expect()` on `Result` or `Option`, which might be better handled"
+    #[clippy::version = "1.70.0"]
+    pub CLEAR_WITH_DRAIN,
+    nursery,
+    "calling `drain` in order to `clear` a container"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for methods that should live in a trait
-    /// implementation of a `std` trait (see [llogiq's blog
-    /// post](http://llogiq.github.io/2015/07/30/traits.html) for further
-    /// information) instead of an inherent implementation.
+    /// Checks for usage of `.clone()` on a `Copy` type.
     ///
     /// ### Why is this bad?
-    /// Implementing the traits improve ergonomics for users of
-    /// the code, often with very little cost. Also people seeing a `mul(...)`
-    /// method
-    /// may expect `*` to work equally, so you should have good reason to disappoint
-    /// them.
+    /// The only reason `Copy` types implement `Clone` is for
+    /// generics, not for using the `clone` method on a concrete type.
     ///
     /// ### Example
     /// ```no_run
-    /// struct X;
-    /// impl X {
-    ///     fn add(&self, other: &X) -> X {
-    ///         // ..
-    /// # X
-    ///     }
-    /// }
+    /// 42u64.clone();
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub SHOULD_IMPLEMENT_TRAIT,
-    style,
-    "defining a method that should be implementing a std trait"
-}
-
+    pub CLONE_ON_COPY,
+    complexity,
+    "using `clone` on a `Copy` type"
+}
+
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for methods with certain name prefixes or suffixes, and which
-    /// do not adhere to standard conventions regarding how `self` is taken.
-    /// The actual rules are:
-    ///
-    /// |Prefix |Postfix     |`self` taken                   | `self` type  |
-    /// |-------|------------|-------------------------------|--------------|
-    /// |`as_`  | none       |`&self` or `&mut self`         | any          |
-    /// |`from_`| none       | none                          | any          |
-    /// |`into_`| none       |`self`                         | any          |
-    /// |`is_`  | none       |`&mut self` or `&self` or none | any          |
-    /// |`to_`  | `_mut`     |`&mut self`                    | any          |
-    /// |`to_`  | not `_mut` |`self`                         | `Copy`       |
-    /// |`to_`  | not `_mut` |`&self`                        | not `Copy`   |
-    ///
-    /// Note: Clippy doesn't trigger methods with `to_` prefix in:
-    /// - Traits definition.
-    /// Clippy can not tell if a type that implements a trait is `Copy` or not.
-    /// - Traits implementation, when `&self` is taken.
-    /// The method signature is controlled by the trait and often `&self` is required for all types that implement the trait
-    /// (see e.g. the `std::string::ToString` trait).
-    ///
-    /// Clippy allows `Pin<&Self>` and `Pin<&mut Self>` if `&self` and `&mut self` is required.
-    ///
-    /// Please find more info here:
-    /// https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
+    /// Checks for usage of `.clone()` on a ref-counted pointer,
+    /// (`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified
+    /// function syntax instead (e.g., `Rc::clone(foo)`).
     ///
-    /// ### Why is this bad?
-    /// Consistency breeds readability. If you follow the
-    /// conventions, your users won't be surprised that they, e.g., need to supply a
-    /// mutable reference to a `as_..` function.
+    /// ### Why restrict this?
+    /// Calling `.clone()` on an `Rc`, `Arc`, or `Weak`
+    /// can obscure the fact that only the pointer is being cloned, not the underlying
+    /// data.
     ///
     /// ### Example
     /// ```no_run
-    /// # struct X;
-    /// impl X {
-    ///     fn as_str(self) -> &'static str {
-    ///         // ..
-    /// # ""
-    ///     }
-    /// }
+    /// # use std::rc::Rc;
+    /// let x = Rc::new(1);
+    ///
+    /// x.clone();
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # struct X;
-    /// impl X {
-    ///     fn as_str(&self) -> &'static str {
-    ///         // ..
-    /// # ""
-    ///     }
-    /// }
+    /// # use std::rc::Rc;
+    /// # let x = Rc::new(1);
+    /// Rc::clone(&x);
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub WRONG_SELF_CONVENTION,
-    style,
-    "defining a method named with an established prefix (like \"into_\") that takes `self` with the wrong convention"
+    pub CLONE_ON_REF_PTR,
+    restriction,
+    "using `clone` on a ref-counted pointer"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `ok().expect(..)`.
-    ///
-    /// Note: This lint only triggers for code marked compatible
-    /// with versions of the compiler older than Rust 1.82.0.
+    /// Checks for usage of `cloned()` on an `Iterator` or `Option` where
+    /// `copied()` could be used instead.
     ///
     /// ### Why is this bad?
-    /// Because you usually call `expect()` on the `Result`
-    /// directly to get a better error message.
+    /// `copied()` is better because it guarantees that the type being cloned
+    /// implements `Copy`.
     ///
     /// ### Example
     /// ```no_run
-    /// # let x = Ok::<_, ()>(());
-    /// x.ok().expect("why did I do this again?");
+    /// [1, 2, 3].iter().cloned();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let x = Ok::<_, ()>(());
-    /// x.expect("why did I do this again?");
+    /// [1, 2, 3].iter().copied();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OK_EXPECT,
-    style,
-    "using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result"
+    #[clippy::version = "1.53.0"]
+    pub CLONED_INSTEAD_OF_COPIED,
+    pedantic,
+    "used `cloned` where `copied` could be used instead"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `.err().expect()` calls on the `Result` type.
+    /// Checks for consecutive calls to `str::replace` (2 or more)
+    /// that can be collapsed into a single call.
     ///
     /// ### Why is this bad?
-    /// `.expect_err()` can be called directly to avoid the extra type conversion from `err()`.
+    /// Consecutive `str::replace` calls scan the string multiple times
+    /// with repetitive code.
     ///
     /// ### Example
-    /// ```should_panic
-    /// let x: Result<u32, &str> = Ok(10);
-    /// x.err().expect("Testing err().expect()");
+    /// ```no_run
+    /// let hello = "hesuo worpd"
+    ///     .replace('s', "l")
+    ///     .replace("u", "l")
+    ///     .replace('p', "l");
     /// ```
     /// Use instead:
-    /// ```should_panic
-    /// let x: Result<u32, &str> = Ok(10);
-    /// x.expect_err("Testing expect_err");
+    /// ```no_run
+    /// let hello = "hesuo worpd".replace(['s', 'u', 'p'], "l");
     /// ```
-    #[clippy::version = "1.62.0"]
-    pub ERR_EXPECT,
-    style,
-    r#"using `.err().expect("")` when `.expect_err("")` can be used"#
+    #[clippy::version = "1.65.0"]
+    pub COLLAPSIBLE_STR_REPLACE,
+    perf,
+    "collapse consecutive calls to str::replace (2 or more) into a single call"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of the following functions with an argument that constructs a default value
-    /// (e.g., `Default::default` or `String::new`):
-    /// - `unwrap_or`
-    /// - `unwrap_or_else`
-    /// - `or_insert`
-    /// - `or_insert_with`
+    /// It identifies calls to `.is_empty()` on constant values.
     ///
     /// ### Why is this bad?
-    /// Readability. Using `unwrap_or_default` in place of `unwrap_or`/`unwrap_or_else`, or `or_default`
-    /// in place of `or_insert`/`or_insert_with`, is simpler and more concise.
-    ///
-    /// ### Known problems
-    /// In some cases, the argument of `unwrap_or`, etc. is needed for type inference. The lint uses a
-    /// heuristic to try to identify such cases. However, the heuristic can produce false negatives.
+    /// String literals and constant values are known at compile time. Checking if they
+    /// are empty will always return the same value. This might not be the intention of
+    /// the expression.
     ///
-    /// ### Examples
+    /// ### Example
     /// ```no_run
-    /// # let x = Some(1);
-    /// # let mut map = std::collections::HashMap::<u64, String>::new();
-    /// x.unwrap_or(Default::default());
-    /// map.entry(42).or_insert_with(String::new);
+    /// let value = "";
+    /// if value.is_empty() {
+    ///     println!("the string is empty");
+    /// }
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let x = Some(1);
-    /// # let mut map = std::collections::HashMap::<u64, String>::new();
-    /// x.unwrap_or_default();
-    /// map.entry(42).or_default();
+    /// println!("the string is empty");
     /// ```
-    #[clippy::version = "1.56.0"]
-    pub UNWRAP_OR_DEFAULT,
-    style,
-    "using `.unwrap_or`, etc. with an argument that constructs a default value"
+    #[clippy::version = "1.79.0"]
+    pub CONST_IS_EMPTY,
+    suspicious,
+    "is_empty() called on strings known at compile time"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or
-    /// `result.map(_).unwrap_or_else(_)`.
+    ///
+    /// Checks for `Iterator::last` being called on a  `DoubleEndedIterator`, which can be replaced
+    /// with `DoubleEndedIterator::next_back`.
     ///
     /// ### Why is this bad?
-    /// Readability, these can be written more concisely (resp.) as
-    /// `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.
     ///
-    /// ### Known problems
-    /// The order of the arguments is not in execution order
+    /// `Iterator::last` is implemented by consuming the iterator, which is unnecessary if
+    /// the iterator is a `DoubleEndedIterator`. Since Rust traits do not allow specialization,
+    /// `Iterator::last` cannot be optimized for `DoubleEndedIterator`.
     ///
-    /// ### Examples
+    /// ### Example
     /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// # fn some_function(foo: ()) -> usize { 1 }
-    /// option.map(|a| a + 1).unwrap_or(0);
-    /// option.map(|a| a > 10).unwrap_or(false);
-    /// result.map(|a| a + 1).unwrap_or_else(some_function);
+    /// let last_arg = "echo hello world".split(' ').last();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// # fn some_function(foo: ()) -> usize { 1 }
-    /// option.map_or(0, |a| a + 1);
-    /// option.is_some_and(|a| a > 10);
-    /// result.map_or_else(some_function, |a| a + 1);
+    /// let last_arg = "echo hello world".split(' ').next_back();
     /// ```
-    #[clippy::version = "1.45.0"]
-    pub MAP_UNWRAP_OR,
-    pedantic,
-    "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`"
+    #[clippy::version = "1.86.0"]
+    pub DOUBLE_ENDED_ITERATOR_LAST,
+    perf,
+    "using `Iterator::last` on a `DoubleEndedIterator`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.map_or(None, _)`.
+    /// Checks for calls to `.drain()` that clear the collection, immediately followed by a call to `.collect()`.
+    ///
+    /// > "Collection" in this context refers to any type with a `drain` method:
+    /// > `Vec`, `VecDeque`, `BinaryHeap`, `HashSet`,`HashMap`, `String`
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.and_then(_)`.
+    /// Using `mem::take` is faster as it avoids the allocation.
+    /// When using `mem::take`, the old collection is replaced with an empty one and ownership of
+    /// the old collection is returned.
     ///
-    /// ### Known problems
-    /// The order of the arguments is not in execution order.
+    /// ### Known issues
+    /// `mem::take(&mut vec)` is almost equivalent to `vec.drain(..).collect()`, except that
+    /// it also moves the **capacity**. The user might have explicitly written it this way
+    /// to keep the capacity on the original `Vec`.
     ///
     /// ### Example
     /// ```no_run
-    /// # let opt = Some(1);
-    /// opt.map_or(None, |a| Some(a + 1));
+    /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
+    ///     v.drain(..).collect()
+    /// }
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let opt = Some(1);
-    /// opt.and_then(|a| Some(a + 1));
+    /// use std::mem;
+    /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
+    ///     mem::take(v)
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OPTION_MAP_OR_NONE,
-    style,
-    "using `Option.map_or(None, f)`, which is more succinctly expressed as `and_then(f)`"
+    #[clippy::version = "1.72.0"]
+    pub DRAIN_COLLECT,
+    perf,
+    "calling `.drain(..).collect()` to move all elements into a new collection"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.map_or(None, Some)`.
+    /// Checks for `.err().expect()` calls on the `Result` type.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.ok()`.
+    /// `.expect_err()` can be called directly to avoid the extra type conversion from `err()`.
     ///
     /// ### Example
-    /// ```no_run
-    /// # let r: Result<u32, &str> = Ok(1);
-    /// assert_eq!(Some(1), r.map_or(None, Some));
+    /// ```should_panic
+    /// let x: Result<u32, &str> = Ok(10);
+    /// x.err().expect("Testing err().expect()");
     /// ```
-    ///
     /// Use instead:
-    /// ```no_run
-    /// # let r: Result<u32, &str> = Ok(1);
-    /// assert_eq!(Some(1), r.ok());
+    /// ```should_panic
+    /// let x: Result<u32, &str> = Ok(10);
+    /// x.expect_err("Testing expect_err");
     /// ```
-    #[clippy::version = "1.44.0"]
-    pub RESULT_MAP_OR_INTO_OPTION,
+    #[clippy::version = "1.62.0"]
+    pub ERR_EXPECT,
     style,
-    "using `Result.map_or(None, Some)`, which is more succinctly expressed as `ok()`"
+    r#"using `.err().expect("")` when `.expect_err("")` can be used"#
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))`
-    /// or `_.or_else(|x| Err(y))`.
+    /// Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,
+    /// etc., and suggests to use `unwrap_or_else` instead
     ///
     /// ### Why is this bad?
-    /// This can be written more concisely as `_.map(|x| y)` or `_.map_err(|x| y)`.
+    /// The function will always be called.
+    ///
+    /// ### Known problems
+    /// If the function has side-effects, not calling it will
+    /// change the semantics of the program, but you shouldn't rely on that anyway.
     ///
     /// ### Example
     /// ```no_run
-    /// # fn opt() -> Option<&'static str> { Some("42") }
-    /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
-    /// let _ = opt().and_then(|s| Some(s.len()));
-    /// let _ = res().and_then(|s| if s.len() == 42 { Ok(10) } else { Ok(20) });
-    /// let _ = res().or_else(|s| if s.len() == 42 { Err(10) } else { Err(20) });
-    /// ```
+    /// # let foo = Some(String::new());
+    /// # let err_code = "418";
+    /// # let err_msg = "I'm a teapot";
+    /// foo.expect(&format!("Err {}: {}", err_code, err_msg));
     ///
-    /// The correct use would be:
+    /// // or
+    ///
+    /// # let foo = Some(String::new());
+    /// foo.expect(format!("Err {}: {}", err_code, err_msg).as_str());
+    /// ```
     ///
+    /// Use instead:
     /// ```no_run
-    /// # fn opt() -> Option<&'static str> { Some("42") }
-    /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
-    /// let _ = opt().map(|s| s.len());
-    /// let _ = res().map(|s| if s.len() == 42 { 10 } else { 20 });
-    /// let _ = res().map_err(|s| if s.len() == 42 { 10 } else { 20 });
+    /// # let foo = Some(String::new());
+    /// # let err_code = "418";
+    /// # let err_msg = "I'm a teapot";
+    /// foo.unwrap_or_else(|| panic!("Err {}: {}", err_code, err_msg));
     /// ```
-    #[clippy::version = "1.45.0"]
-    pub BIND_INSTEAD_OF_MAP,
-    complexity,
-    "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`"
+    #[clippy::version = "pre 1.29.0"]
+    pub EXPECT_FUN_CALL,
+    perf,
+    "using any `expect` method with a function call"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.filter(_).next()`.
+    /// Checks for `.expect()` or `.expect_err()` calls on `Result`s and `.expect()` call on `Option`s.
     ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.find(_)`.
+    /// ### Why restrict this?
+    /// Usually it is better to handle the `None` or `Err` case.
+    /// Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why
+    /// this lint is `Allow` by default.
     ///
-    /// ### Example
-    /// ```no_run
-    /// # let vec = vec![1];
-    /// vec.iter().filter(|x| **x == 0).next();
+    /// `result.expect()` will let the thread panic on `Err`
+    /// values. Normally, you want to implement more sophisticated error handling,
+    /// and propagate errors upwards with `?` operator.
+    ///
+    /// ### Examples
+    /// ```rust,ignore
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.expect("one");
+    /// result.expect("one");
     /// ```
     ///
     /// Use instead:
-    /// ```no_run
-    /// # let vec = vec![1];
-    /// vec.iter().find(|x| **x == 0);
+    /// ```rust,ignore
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option?;
+    ///
+    /// // or
+    ///
+    /// result?;
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FILTER_NEXT,
-    complexity,
-    "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`"
+    #[clippy::version = "1.45.0"]
+    pub EXPECT_USED,
+    restriction,
+    "using `.expect()` on `Result` or `Option`, which might be better handled"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.skip_while(condition).next()`.
+    /// Checks for occurrences where one vector gets extended instead of append
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.find(!condition)`.
+    /// Using `append` instead of `extend` is more concise and faster
     ///
     /// ### Example
     /// ```no_run
-    /// # let vec = vec![1];
-    /// vec.iter().skip_while(|x| **x == 0).next();
+    /// let mut a = vec![1, 2, 3];
+    /// let mut b = vec![4, 5, 6];
+    ///
+    /// a.extend(b.drain(..));
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # let vec = vec![1];
-    /// vec.iter().find(|x| **x != 0);
+    /// let mut a = vec![1, 2, 3];
+    /// let mut b = vec![4, 5, 6];
+    ///
+    /// a.append(&mut b);
     /// ```
-    #[clippy::version = "1.42.0"]
-    pub SKIP_WHILE_NEXT,
-    complexity,
-    "using `skip_while(p).next()`, which is more succinctly expressed as `.find(!p)`"
+    #[clippy::version = "1.55.0"]
+    pub EXTEND_WITH_DRAIN,
+    perf,
+    "using vec.append(&mut vec) to move the full range of a vector to another"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.map(_).flatten(_)` on `Iterator` and `Option`
+    /// Checks for `FileType::is_file()`.
     ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.flat_map(_)` for `Iterator` or `_.and_then(_)` for `Option`
+    /// ### Why restrict this?
+    /// When people testing a file type with `FileType::is_file`
+    /// they are testing whether a path is something they can get bytes from. But
+    /// `is_file` doesn't cover special file types in unix-like systems, and doesn't cover
+    /// symlink in windows. Using `!FileType::is_dir()` is a better way to that intention.
     ///
     /// ### Example
     /// ```no_run
-    /// let vec = vec![vec![1]];
-    /// let opt = Some(5);
+    /// # || {
+    /// let metadata = std::fs::metadata("foo.txt")?;
+    /// let filetype = metadata.file_type();
     ///
-    /// vec.iter().map(|x| x.iter()).flatten();
-    /// opt.map(|x| Some(x * 2)).flatten();
+    /// if filetype.is_file() {
+    ///     // read file
+    /// }
+    /// # Ok::<_, std::io::Error>(())
+    /// # };
     /// ```
     ///
-    /// Use instead:
+    /// should be written as:
+    ///
     /// ```no_run
-    /// # let vec = vec![vec![1]];
-    /// # let opt = Some(5);
-    /// vec.iter().flat_map(|x| x.iter());
-    /// opt.and_then(|x| Some(x * 2));
+    /// # || {
+    /// let metadata = std::fs::metadata("foo.txt")?;
+    /// let filetype = metadata.file_type();
+    ///
+    /// if !filetype.is_dir() {
+    ///     // read file
+    /// }
+    /// # Ok::<_, std::io::Error>(())
+    /// # };
     /// ```
-    #[clippy::version = "1.31.0"]
-    pub MAP_FLATTEN,
-    complexity,
-    "using combinations of `flatten` and `map` which can usually be written as a single method call"
+    #[clippy::version = "1.42.0"]
+    pub FILETYPE_IS_FILE,
+    restriction,
+    "`FileType::is_file` is not recommended to test for readable file type"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.filter(_).map(_)` that can be written more simply
-    /// as `filter_map(_)`.
+    /// Checks for usage of `bool::then` in `Iterator::filter_map`.
     ///
     /// ### Why is this bad?
-    /// Redundant code in the `filter` and `map` operations is poor style and
-    /// less performant.
+    /// This can be written with `filter` then `map` instead, which would reduce nesting and
+    /// separates the filtering from the transformation phase. This comes with no cost to
+    /// performance and is just cleaner.
     ///
-     /// ### Example
+    /// ### Limitations
+    /// Does not lint `bool::then_some`, as it eagerly evaluates its arguments rather than lazily.
+    /// This can create differing behavior, so better safe than sorry.
+    ///
+    /// ### Example
     /// ```no_run
-    /// (0_i32..10)
-    ///     .filter(|n| n.checked_add(1).is_some())
-    ///     .map(|n| n.checked_add(1).unwrap());
+    /// # fn really_expensive_fn(i: i32) -> i32 { i }
+    /// # let v = vec![];
+    /// _ = v.into_iter().filter_map(|i| (i % 2 == 0).then(|| really_expensive_fn(i)));
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// (0_i32..10).filter_map(|n| n.checked_add(1));
+    /// # fn really_expensive_fn(i: i32) -> i32 { i }
+    /// # let v = vec![];
+    /// _ = v.into_iter().filter(|i| i % 2 == 0).map(|i| really_expensive_fn(i));
     /// ```
-    #[clippy::version = "1.51.0"]
-    pub MANUAL_FILTER_MAP,
-    complexity,
-    "using `_.filter(_).map(_)` in a way that can be written more simply as `filter_map(_)`"
+    #[clippy::version = "1.73.0"]
+    pub FILTER_MAP_BOOL_THEN,
+    style,
+    "checks for usage of `bool::then` in `Iterator::filter_map`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.find(_).map(_)` that can be written more simply
-    /// as `find_map(_)`.
+    /// Checks for usage of `filter_map(|x| x)`.
     ///
     /// ### Why is this bad?
-    /// Redundant code in the `find` and `map` operations is poor style and
-    /// less performant.
+    /// Readability, this can be written more concisely by using `flatten`.
     ///
-     /// ### Example
+    /// ### Example
     /// ```no_run
-    /// (0_i32..10)
-    ///     .find(|n| n.checked_add(1).is_some())
-    ///     .map(|n| n.checked_add(1).unwrap());
+    /// # let iter = vec![Some(1)].into_iter();
+    /// iter.filter_map(|x| x);
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// (0_i32..10).find_map(|n| n.checked_add(1));
+    /// # let iter = vec![Some(1)].into_iter();
+    /// iter.flatten();
     /// ```
-    #[clippy::version = "1.51.0"]
-    pub MANUAL_FIND_MAP,
+    #[clippy::version = "1.52.0"]
+    pub FILTER_MAP_IDENTITY,
     complexity,
-    "using `_.find(_).map(_)` in a way that can be written more simply as `find_map(_)`"
+    "call to `filter_map` where `flatten` is sufficient"
 }
 
 declare_clippy_lint! {
@@ -839,6 +779,31 @@ declare_clippy_lint! {
     "using combination of `filter_map` and `next` which can usually be written as a single method call"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.filter(_).next()`.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.find(_)`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let vec = vec![1];
+    /// vec.iter().filter(|x| **x == 0).next();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let vec = vec![1];
+    /// vec.iter().find(|x| **x == 0);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub FILTER_NEXT,
+    complexity,
+    "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `flat_map(|x| x)`.
@@ -864,217 +829,227 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for an iterator or string search (such as `find()`,
-    /// `position()`, or `rposition()`) followed by a call to `is_some()` or `is_none()`.
+    /// Checks for usage of `Iterator::flat_map()` where `filter_map()` could be
+    /// used instead.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely as:
-    /// * `_.any(_)`, or `_.contains(_)` for `is_some()`,
-    /// * `!_.any(_)`, or `!_.contains(_)` for `is_none()`.
+    /// `filter_map()` is known to always produce 0 or 1 output items per input item,
+    /// rather than however many the inner iterator type produces.
+    /// Therefore, it maintains the upper bound in `Iterator::size_hint()`,
+    /// and communicates to the reader that the input items are not being expanded into
+    /// multiple output items without their having to notice that the mapping function
+    /// returns an `Option`.
     ///
     /// ### Example
     /// ```no_run
-    /// let vec = vec![1];
-    /// vec.iter().find(|x| **x == 0).is_some();
-    ///
-    /// "hello world".find("world").is_none();
+    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().flat_map(|x| x.parse().ok()).collect();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// let vec = vec![1];
-    /// vec.iter().any(|x| *x == 0);
-    ///
-    /// !"hello world".contains("world");
+    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().filter_map(|x| x.parse().ok()).collect();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub SEARCH_IS_SOME,
-    nursery,
-    "using an iterator or string search followed by `is_some()` or `is_none()`, which is more succinctly expressed as a call to `any()` or `contains()` (with negation in case of `is_none()`)"
+    #[clippy::version = "1.53.0"]
+    pub FLAT_MAP_OPTION,
+    pedantic,
+    "used `flat_map` where `filter_map` could be used instead"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.chars().next()` on a `str` to check
-    /// if it starts with a given char.
+    /// Checks for usage of `.map(|_| format!(..)).collect::<String>()`.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.starts_with(_)`.
+    /// This allocates a new string for every element in the iterator.
+    /// This can be done more efficiently by creating the `String` once and appending to it in `Iterator::fold`,
+    /// using either the `write!` macro which supports exactly the same syntax as the `format!` macro,
+    /// or concatenating with `+` in case the iterator yields `&str`/`String`.
+    ///
+    /// Note also that `write!`-ing into a `String` can never fail, despite the return type of `write!` being `std::fmt::Result`,
+    /// so it can be safely ignored or unwrapped.
     ///
     /// ### Example
     /// ```no_run
-    /// let name = "foo";
-    /// if name.chars().next() == Some('_') {};
+    /// fn hex_encode(bytes: &[u8]) -> String {
+    ///     bytes.iter().map(|b| format!("{b:02X}")).collect()
+    /// }
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// let name = "foo";
-    /// if name.starts_with('_') {};
+    /// use std::fmt::Write;
+    /// fn hex_encode(bytes: &[u8]) -> String {
+    ///     bytes.iter().fold(String::new(), |mut output, b| {
+    ///         let _ = write!(output, "{b:02X}");
+    ///         output
+    ///     })
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub CHARS_NEXT_CMP,
-    style,
-    "using `.chars().next()` to check if a string starts with a char"
+    #[clippy::version = "1.73.0"]
+    pub FORMAT_COLLECT,
+    pedantic,
+    "`format!`ing every element in a collection, then collecting the strings into a new `String`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
-    /// `.or_insert(foo(..))` etc., and suggests to use `.or_else(|| foo(..))`,
-    /// `.unwrap_or_else(|| foo(..))`, `.unwrap_or_default()` or `.or_default()`
-    /// etc. instead.
+    /// Checks for `from_iter()` function calls on types that implement the `FromIterator`
+    /// trait.
     ///
     /// ### Why is this bad?
-    /// The function will always be called. This is only bad if it allocates or
-    /// does some non-trivial amount of work.
-    ///
-    /// ### Known problems
-    /// If the function has side-effects, not calling it will change the
-    /// semantic of the program, but you shouldn't rely on that.
-    ///
-    /// The lint also cannot figure out whether the function you call is
-    /// actually expensive to call or not.
+    /// If it's needed to create a collection from the contents of an iterator, the `Iterator::collect(_)`
+    /// method is preferred. However, when it's needed to specify the container type,
+    /// `Vec::from_iter(_)` can be more readable than using a turbofish (e.g. `_.collect::<Vec<_>>()`). See
+    /// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)
     ///
     /// ### Example
     /// ```no_run
-    /// # let foo = Some(String::new());
-    /// foo.unwrap_or(String::from("empty"));
-    /// ```
+    /// let five_fives = std::iter::repeat(5).take(5);
+    ///
+    /// let v = Vec::from_iter(five_fives);
     ///
+    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
+    /// ```
     /// Use instead:
     /// ```no_run
-    /// # let foo = Some(String::new());
-    /// foo.unwrap_or_else(|| String::from("empty"));
+    /// let five_fives = std::iter::repeat(5).take(5);
+    ///
+    /// let v: Vec<i32> = five_fives.collect();
+    ///
+    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OR_FUN_CALL,
-    nursery,
-    "using any `*or` method with a function call, which suggests `*or_else`"
+    /// but prefer to use
+    /// ```no_run
+    /// let numbers: Vec<i32> = FromIterator::from_iter(1..=5);
+    /// ```
+    /// instead of
+    /// ```no_run
+    /// let numbers = (1..=5).collect::<Vec<_>>();
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub FROM_ITER_INSTEAD_OF_COLLECT,
+    pedantic,
+    "use `.collect()` instead of `::from_iter()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `.or(…).unwrap()` calls to Options and Results.
+    /// Checks for usage of `x.get(0)` instead of
+    /// `x.first()` or `x.front()`.
     ///
     /// ### Why is this bad?
-    /// You should use `.unwrap_or(…)` instead for clarity.
+    /// Using `x.first()` for `Vec`s and slices or `x.front()`
+    /// for `VecDeque`s is easier to read and has the same result.
     ///
     /// ### Example
     /// ```no_run
-    /// # let fallback = "fallback";
-    /// // Result
-    /// # type Error = &'static str;
-    /// # let result: Result<&str, Error> = Err("error");
-    /// let value = result.or::<Error>(Ok(fallback)).unwrap();
-    ///
-    /// // Option
-    /// # let option: Option<&str> = None;
-    /// let value = option.or(Some(fallback)).unwrap();
+    /// let x = vec![2, 3, 5];
+    /// let first_element = x.get(0);
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// # let fallback = "fallback";
-    /// // Result
-    /// # let result: Result<&str, &str> = Err("error");
-    /// let value = result.unwrap_or(fallback);
-    ///
-    /// // Option
-    /// # let option: Option<&str> = None;
-    /// let value = option.unwrap_or(fallback);
+    /// let x = vec![2, 3, 5];
+    /// let first_element = x.first();
     /// ```
-    #[clippy::version = "1.61.0"]
-    pub OR_THEN_UNWRAP,
-    complexity,
-    "checks for `.or(…).unwrap()` calls to Options and Results."
+    #[clippy::version = "1.63.0"]
+    pub GET_FIRST,
+    style,
+    "Using `x.get(0)` when `x.first()` or `x.front()` is simpler"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,
-    /// etc., and suggests to use `unwrap_or_else` instead
+    /// Checks for usage of `x.get(x.len() - 1)` instead of
+    /// `x.last()`.
     ///
     /// ### Why is this bad?
-    /// The function will always be called.
+    /// Using `x.last()` is easier to read and has the same
+    /// result.
     ///
-    /// ### Known problems
-    /// If the function has side-effects, not calling it will
-    /// change the semantics of the program, but you shouldn't rely on that anyway.
+    /// Note that using `x[x.len() - 1]` is semantically different from
+    /// `x.last()`.  Indexing into the array will panic on out-of-bounds
+    /// accesses, while `x.get()` and `x.last()` will return `None`.
+    ///
+    /// There is another lint (get_unwrap) that covers the case of using
+    /// `x.get(index).unwrap()` instead of `x[index]`.
     ///
     /// ### Example
     /// ```no_run
-    /// # let foo = Some(String::new());
-    /// # let err_code = "418";
-    /// # let err_msg = "I'm a teapot";
-    /// foo.expect(&format!("Err {}: {}", err_code, err_msg));
-    ///
-    /// // or
-    ///
-    /// # let foo = Some(String::new());
-    /// foo.expect(format!("Err {}: {}", err_code, err_msg).as_str());
+    /// let x = vec![2, 3, 5];
+    /// let last_element = x.get(x.len() - 1);
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # let foo = Some(String::new());
-    /// # let err_code = "418";
-    /// # let err_msg = "I'm a teapot";
-    /// foo.unwrap_or_else(|| panic!("Err {}: {}", err_code, err_msg));
+    /// let x = vec![2, 3, 5];
+    /// let last_element = x.last();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EXPECT_FUN_CALL,
-    perf,
-    "using any `expect` method with a function call"
+    #[clippy::version = "1.37.0"]
+    pub GET_LAST_WITH_LEN,
+    complexity,
+    "Using `x.get(x.len() - 1)` when `x.last()` is correct and simpler"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.clone()` on a `Copy` type.
+    /// Checks for usage of `.get().unwrap()` (or
+    /// `.get_mut().unwrap`) on a standard library type which implements `Index`
     ///
-    /// ### Why is this bad?
-    /// The only reason `Copy` types implement `Clone` is for
-    /// generics, not for using the `clone` method on a concrete type.
+    /// ### Why restrict this?
+    /// Using the Index trait (`[]`) is more clear and more
+    /// concise.
+    ///
+    /// ### Known problems
+    /// Not a replacement for error handling: Using either
+    /// `.unwrap()` or the Index trait (`[]`) carries the risk of causing a `panic`
+    /// if the value being accessed is `None`. If the use of `.get().unwrap()` is a
+    /// temporary placeholder for dealing with the `Option` type, then this does
+    /// not mitigate the need for error handling. If there is a chance that `.get()`
+    /// will be `None` in your program, then it is advisable that the `None` case
+    /// is handled in a future refactor instead of using `.unwrap()` or the Index
+    /// trait.
     ///
     /// ### Example
     /// ```no_run
-    /// 42u64.clone();
+    /// let mut some_vec = vec![0, 1, 2, 3];
+    /// let last = some_vec.get(3).unwrap();
+    /// *some_vec.get_mut(0).unwrap() = 1;
+    /// ```
+    /// The correct use would be:
+    /// ```no_run
+    /// let mut some_vec = vec![0, 1, 2, 3];
+    /// let last = some_vec[3];
+    /// some_vec[0] = 1;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub CLONE_ON_COPY,
-    complexity,
-    "using `clone` on a `Copy` type"
+    pub GET_UNWRAP,
+    restriction,
+    "using `.get().unwrap()` or `.get_mut().unwrap()` when using `[]` would work instead"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.clone()` on a ref-counted pointer,
-    /// (`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified
-    /// function syntax instead (e.g., `Rc::clone(foo)`).
+    /// Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.
     ///
-    /// ### Why restrict this?
-    /// Calling `.clone()` on an `Rc`, `Arc`, or `Weak`
-    /// can obscure the fact that only the pointer is being cloned, not the underlying
-    /// data.
+    /// ### Why is this bad?
+    /// These methods do the same thing as `_.clone()` but may be confusing as
+    /// to why we are calling `to_vec` on something that is already a `Vec` or calling `to_owned` on something that is already owned.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::rc::Rc;
-    /// let x = Rc::new(1);
-    ///
-    /// x.clone();
+    /// let a = vec![1, 2, 3];
+    /// let b = a.to_vec();
+    /// let c = a.to_owned();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # use std::rc::Rc;
-    /// # let x = Rc::new(1);
-    /// Rc::clone(&x);
+    /// let a = vec![1, 2, 3];
+    /// let b = a.clone();
+    /// let c = a.clone();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub CLONE_ON_REF_PTR,
-    restriction,
-    "using `clone` on a ref-counted pointer"
+    #[clippy::version = "1.52.0"]
+    pub IMPLICIT_CLONE,
+    pedantic,
+    "implicitly cloning a value by invoking a function on its dereferenced type"
 }
 
 declare_clippy_lint! {
@@ -1103,1848 +1078,1857 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `new` not returning a type that contains `Self`.
+    /// Checks for usage of `inspect().for_each()`.
     ///
     /// ### Why is this bad?
-    /// As a convention, `new` methods are used to make a new
-    /// instance of a type.
+    /// It is the same as performing the computation
+    /// inside `inspect` at the beginning of the closure in `for_each`.
     ///
     /// ### Example
-    /// In an impl block:
     /// ```no_run
-    /// # struct Foo;
-    /// # struct NotAFoo;
-    /// impl Foo {
-    ///     fn new() -> NotAFoo {
-    /// # NotAFoo
-    ///     }
-    /// }
+    /// [1,2,3,4,5].iter()
+    /// .inspect(|&x| println!("inspect the number: {}", x))
+    /// .for_each(|&x| {
+    ///     assert!(x >= 0);
+    /// });
     /// ```
-    ///
+    /// Can be written as
     /// ```no_run
-    /// # struct Foo;
-    /// struct Bar(Foo);
-    /// impl Foo {
-    ///     // Bad. The type name must contain `Self`
-    ///     fn new() -> Bar {
-    /// # Bar(Foo)
-    ///     }
-    /// }
+    /// [1,2,3,4,5].iter()
+    /// .for_each(|&x| {
+    ///     println!("inspect the number: {}", x);
+    ///     assert!(x >= 0);
+    /// });
     /// ```
+    #[clippy::version = "1.51.0"]
+    pub INSPECT_FOR_EACH,
+    complexity,
+    "using `.inspect().for_each()`, which can be replaced with `.for_each()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `into_iter` calls on references which should be replaced by `iter`
+    /// or `iter_mut`.
     ///
-    /// ```no_run
-    /// # struct Foo;
-    /// # struct FooError;
-    /// impl Foo {
-    ///     // Good. Return type contains `Self`
-    ///     fn new() -> Result<Foo, FooError> {
-    /// # Ok(Foo)
-    ///     }
-    /// }
-    /// ```
+    /// ### Why is this bad?
+    /// Readability. Calling `into_iter` on a reference will not move out its
+    /// content into the resulting iterator, which is confusing. It is better just call `iter` or
+    /// `iter_mut` directly.
     ///
-    /// Or in a trait definition:
+    /// ### Example
     /// ```no_run
-    /// pub trait Trait {
-    ///     // Bad. The type name must contain `Self`
-    ///     fn new();
-    /// }
+    /// # let vec = vec![3, 4, 5];
+    /// (&vec).into_iter();
     /// ```
     ///
+    /// Use instead:
     /// ```no_run
-    /// pub trait Trait {
-    ///     // Good. Return type contains `Self`
-    ///     fn new() -> Self;
-    /// }
+    /// # let vec = vec![3, 4, 5];
+    /// (&vec).iter();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NEW_RET_NO_SELF,
+    #[clippy::version = "1.32.0"]
+    pub INTO_ITER_ON_REF,
     style,
-    "not returning type containing `Self` in a `new` method"
+    "using `.into_iter()` on a reference"
 }
 
 declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calling `.step_by(0)` on iterators which panics.
+    /// This lint warns on calling `io::Error::new(..)` with a kind of
+    /// `io::ErrorKind::Other`.
     ///
     /// ### Why is this bad?
-    /// This very much looks like an oversight. Use `panic!()` instead if you
-    /// actually intend to panic.
+    /// Since Rust 1.74, there's the `io::Error::other(_)` shortcut.
     ///
     /// ### Example
-    /// ```rust,should_panic
-    /// for x in (0..100).step_by(0) {
-    ///     //..
-    /// }
+    /// ```no_run
+    /// use std::io;
+    /// let _ = io::Error::new(io::ErrorKind::Other, "bad".to_string());
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ITERATOR_STEP_BY_ZERO,
-    correctness,
-    "using `Iterator::step_by(0)`, which will panic at runtime"
+    /// Use instead:
+    /// ```no_run
+    /// let _ = std::io::Error::other("bad".to_string());
+    /// ```
+    #[clippy::version = "1.87.0"]
+    pub IO_OTHER_ERROR,
+    style,
+    "calling `std::io::Error::new(std::io::ErrorKind::Other, _)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for iterators of `Option`s using `.filter(Option::is_some).map(Option::unwrap)` that may
-    /// be replaced with a `.flatten()` call.
+    /// Checks for IP addresses that could be replaced with predefined constants such as
+    /// `Ipv4Addr::new(127, 0, 0, 1)` instead of using the appropriate constants.
     ///
     /// ### Why is this bad?
-    /// `Option` is like a collection of 0-1 things, so `flatten`
-    /// automatically does this without suspicious-looking `unwrap` calls.
+    /// Using specific IP addresses like `127.0.0.1` or `::1` is less clear and less maintainable than using the
+    /// predefined constants `Ipv4Addr::LOCALHOST` or `Ipv6Addr::LOCALHOST`. These constants improve code
+    /// readability, make the intent explicit, and are less error-prone.
     ///
     /// ### Example
     /// ```no_run
-    /// let _ = std::iter::empty::<Option<i32>>().filter(Option::is_some).map(Option::unwrap);
+    /// use std::net::{Ipv4Addr, Ipv6Addr};
+    ///
+    /// // IPv4 loopback
+    /// let addr_v4 = Ipv4Addr::new(127, 0, 0, 1);
+    ///
+    /// // IPv6 loopback
+    /// let addr_v6 = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let _ = std::iter::empty::<Option<i32>>().flatten();
+    /// use std::net::{Ipv4Addr, Ipv6Addr};
+    ///
+    /// // IPv4 loopback
+    /// let addr_v4 = Ipv4Addr::LOCALHOST;
+    ///
+    /// // IPv6 loopback
+    /// let addr_v6 = Ipv6Addr::LOCALHOST;
     /// ```
-    #[clippy::version = "1.53.0"]
-    pub OPTION_FILTER_MAP,
-    complexity,
-    "filtering `Option` for `Some` then force-unwrapping, which can be one type-safe operation"
+    #[clippy::version = "1.89.0"]
+    pub IP_CONSTANT,
+    pedantic,
+    "hardcoded localhost IP address"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the use of `iter.nth(0)`.
+    /// Finds usages of [`char::is_digit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_digit) that
+    /// can be replaced with [`is_ascii_digit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_digit) or
+    /// [`is_ascii_hexdigit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_hexdigit).
     ///
     /// ### Why is this bad?
-    /// `iter.next()` is equivalent to
-    /// `iter.nth(0)`, as they both consume the next element,
-    ///  but is more readable.
+    /// `is_digit(..)` is slower and requires specifying the radix.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// # let mut s = HashSet::new();
-    /// # s.insert(1);
-    /// let x = s.iter().nth(0);
+    /// let c: char = '6';
+    /// c.is_digit(10);
+    /// c.is_digit(16);
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// # let mut s = HashSet::new();
-    /// # s.insert(1);
-    /// let x = s.iter().next();
+    /// let c: char = '6';
+    /// c.is_ascii_digit();
+    /// c.is_ascii_hexdigit();
     /// ```
-    #[clippy::version = "1.42.0"]
-    pub ITER_NTH_ZERO,
+    #[clippy::version = "1.62.0"]
+    pub IS_DIGIT_ASCII_RADIX,
     style,
-    "replace `iter.nth(0)` with `iter.next()`"
+    "use of `char::is_digit(..)` with literal radix of 10 or 16"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.iter().nth()`/`.iter_mut().nth()` on standard library types that have
-    /// equivalent `.get()`/`.get_mut()` methods.
+    /// Checks for the use of `.cloned().collect()` on slice to
+    /// create a `Vec`.
     ///
     /// ### Why is this bad?
-    /// `.get()` and `.get_mut()` are equivalent but more concise.
+    /// `.to_vec()` is clearer
     ///
     /// ### Example
     /// ```no_run
-    /// let some_vec = vec![0, 1, 2, 3];
-    /// let bad_vec = some_vec.iter().nth(3);
-    /// let bad_slice = &some_vec[..].iter().nth(3);
+    /// let s = [1, 2, 3, 4, 5];
+    /// let s2: Vec<isize> = s[..].iter().cloned().collect();
     /// ```
-    /// The correct use would be:
+    /// The better use would be:
     /// ```no_run
-    /// let some_vec = vec![0, 1, 2, 3];
-    /// let bad_vec = some_vec.get(3);
-    /// let bad_slice = &some_vec[..].get(3);
+    /// let s = [1, 2, 3, 4, 5];
+    /// let s2: Vec<isize> = s.to_vec();
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub ITER_NTH,
+    pub ITER_CLONED_COLLECT,
     style,
-    "using `.iter().nth()` on a standard library type with O(1) element access"
+    "using `.cloned().collect()` on slice to create a `Vec`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.skip(x).next()` on iterators.
+    /// Checks for the use of `.iter().count()`.
     ///
     /// ### Why is this bad?
-    /// `.nth(x)` is cleaner
+    /// `.len()` is more efficient and more
+    /// readable.
     ///
     /// ### Example
     /// ```no_run
     /// let some_vec = vec![0, 1, 2, 3];
-    /// let bad_vec = some_vec.iter().skip(3).next();
-    /// let bad_slice = &some_vec[..].iter().skip(3).next();
+    ///
+    /// some_vec.iter().count();
+    /// &some_vec[..].iter().count();
     /// ```
-    /// The correct use would be:
+    ///
+    /// Use instead:
     /// ```no_run
     /// let some_vec = vec![0, 1, 2, 3];
-    /// let bad_vec = some_vec.iter().nth(3);
-    /// let bad_slice = &some_vec[..].iter().nth(3);
+    ///
+    /// some_vec.len();
+    /// &some_vec[..].len();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ITER_SKIP_NEXT,
-    style,
-    "using `.skip(x).next()` on an iterator"
+    #[clippy::version = "1.52.0"]
+    pub ITER_COUNT,
+    complexity,
+    "replace `.iter().count()` with `.len()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.drain(..)` on `Vec` and `VecDeque` for iteration.
+    /// Checks for usage of `.filter(Result::is_ok)` that may be replaced with a `.flatten()` call.
+    /// This lint will require additional changes to the follow-up calls as it affects the type.
     ///
     /// ### Why is this bad?
-    /// `.into_iter()` is simpler with better performance.
+    /// This pattern is often followed by manual unwrapping of `Result`. The simplification
+    /// results in more readable and succinct code without the need for manual unwrapping.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// let mut foo = vec![0, 1, 2, 3];
-    /// let bar: HashSet<usize> = foo.drain(..).collect();
+    /// vec![Ok::<i32, String>(1)].into_iter().filter(Result::is_ok);
+    ///
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// let foo = vec![0, 1, 2, 3];
-    /// let bar: HashSet<usize> = foo.into_iter().collect();
+    /// vec![Ok::<i32, String>(1)].into_iter().flatten();
     /// ```
-    #[clippy::version = "1.61.0"]
-    pub ITER_WITH_DRAIN,
-    nursery,
-    "replace `.drain(..)` with `.into_iter()`"
+    #[clippy::version = "1.77.0"]
+    pub ITER_FILTER_IS_OK,
+    pedantic,
+    "filtering an iterator over `Result`s for `Ok` can be achieved with `flatten`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `x.get(x.len() - 1)` instead of
-    /// `x.last()`.
+    /// Checks for usage of `.filter(Option::is_some)` that may be replaced with a `.flatten()` call.
+    /// This lint will require additional changes to the follow-up calls as it affects the type.
     ///
     /// ### Why is this bad?
-    /// Using `x.last()` is easier to read and has the same
-    /// result.
-    ///
-    /// Note that using `x[x.len() - 1]` is semantically different from
-    /// `x.last()`.  Indexing into the array will panic on out-of-bounds
-    /// accesses, while `x.get()` and `x.last()` will return `None`.
-    ///
-    /// There is another lint (get_unwrap) that covers the case of using
-    /// `x.get(index).unwrap()` instead of `x[index]`.
+    /// This pattern is often followed by manual unwrapping of the `Option`. The simplification
+    /// results in more readable and succinct code without the need for manual unwrapping.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = vec![2, 3, 5];
-    /// let last_element = x.get(x.len() - 1);
-    /// ```
+    /// vec![Some(1)].into_iter().filter(Option::is_some);
     ///
+    /// ```
     /// Use instead:
     /// ```no_run
-    /// let x = vec![2, 3, 5];
-    /// let last_element = x.last();
+    /// vec![Some(1)].into_iter().flatten();
     /// ```
-    #[clippy::version = "1.37.0"]
-    pub GET_LAST_WITH_LEN,
-    complexity,
-    "Using `x.get(x.len() - 1)` when `x.last()` is correct and simpler"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.get().unwrap()` (or
-    /// `.get_mut().unwrap`) on a standard library type which implements `Index`
-    ///
-    /// ### Why restrict this?
-    /// Using the Index trait (`[]`) is more clear and more
-    /// concise.
-    ///
-    /// ### Known problems
-    /// Not a replacement for error handling: Using either
-    /// `.unwrap()` or the Index trait (`[]`) carries the risk of causing a `panic`
-    /// if the value being accessed is `None`. If the use of `.get().unwrap()` is a
-    /// temporary placeholder for dealing with the `Option` type, then this does
-    /// not mitigate the need for error handling. If there is a chance that `.get()`
-    /// will be `None` in your program, then it is advisable that the `None` case
-    /// is handled in a future refactor instead of using `.unwrap()` or the Index
-    /// trait.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let mut some_vec = vec![0, 1, 2, 3];
-    /// let last = some_vec.get(3).unwrap();
-    /// *some_vec.get_mut(0).unwrap() = 1;
-    /// ```
-    /// The correct use would be:
-    /// ```no_run
-    /// let mut some_vec = vec![0, 1, 2, 3];
-    /// let last = some_vec[3];
-    /// some_vec[0] = 1;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub GET_UNWRAP,
-    restriction,
-    "using `.get().unwrap()` or `.get_mut().unwrap()` when using `[]` would work instead"
+    #[clippy::version = "1.77.0"]
+    pub ITER_FILTER_IS_SOME,
+    pedantic,
+    "filtering an iterator over `Option`s for `Some` can be achieved with `flatten`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for occurrences where one vector gets extended instead of append
+    ///
+    /// Checks for iterating a map (`HashMap` or `BTreeMap`) and
+    /// ignoring either the keys or values.
     ///
     /// ### Why is this bad?
-    /// Using `append` instead of `extend` is more concise and faster
+    ///
+    /// Readability. There are `keys` and `values` methods that
+    /// can be used to express that we only need the keys or the values.
     ///
     /// ### Example
-    /// ```no_run
-    /// let mut a = vec![1, 2, 3];
-    /// let mut b = vec![4, 5, 6];
     ///
-    /// a.extend(b.drain(..));
+    /// ```no_run
+    /// # use std::collections::HashMap;
+    /// let map: HashMap<u32, u32> = HashMap::new();
+    /// let values = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// let mut a = vec![1, 2, 3];
-    /// let mut b = vec![4, 5, 6];
-    ///
-    /// a.append(&mut b);
+    /// # use std::collections::HashMap;
+    /// let map: HashMap<u32, u32> = HashMap::new();
+    /// let values = map.values().collect::<Vec<_>>();
     /// ```
-    #[clippy::version = "1.55.0"]
-    pub EXTEND_WITH_DRAIN,
-    perf,
-    "using vec.append(&mut vec) to move the full range of a vector to another"
+    #[clippy::version = "1.66.0"]
+    pub ITER_KV_MAP,
+    complexity,
+    "iterating on map using `iter` when `keys` or `values` would do"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the use of `.extend(s.chars())` where s is a
-    /// `&str` or `String`.
+    /// Checks for usage of `iter().next()` on a Slice or an Array
     ///
     /// ### Why is this bad?
-    /// `.push_str(s)` is clearer
+    /// These can be shortened into `.get()`
     ///
     /// ### Example
     /// ```no_run
-    /// let abc = "abc";
-    /// let def = String::from("def");
-    /// let mut s = String::new();
-    /// s.extend(abc.chars());
-    /// s.extend(def.chars());
+    /// # let a = [1, 2, 3];
+    /// # let b = vec![1, 2, 3];
+    /// a[2..].iter().next();
+    /// b.iter().next();
     /// ```
-    /// The correct use would be:
+    /// should be written as:
     /// ```no_run
-    /// let abc = "abc";
-    /// let def = String::from("def");
-    /// let mut s = String::new();
-    /// s.push_str(abc);
-    /// s.push_str(&def);
+    /// # let a = [1, 2, 3];
+    /// # let b = vec![1, 2, 3];
+    /// a.get(2);
+    /// b.get(0);
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub STRING_EXTEND_CHARS,
+    #[clippy::version = "1.46.0"]
+    pub ITER_NEXT_SLICE,
     style,
-    "using `x.extend(s.chars())` where s is a `&str` or `String`"
+    "using `.iter().next()` on a sliced array, which can be shortened to just `.get()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the use of `.cloned().collect()` on slice to
-    /// create a `Vec`.
+    /// Checks for usage of `.iter().nth()`/`.iter_mut().nth()` on standard library types that have
+    /// equivalent `.get()`/`.get_mut()` methods.
     ///
     /// ### Why is this bad?
-    /// `.to_vec()` is clearer
+    /// `.get()` and `.get_mut()` are equivalent but more concise.
     ///
     /// ### Example
     /// ```no_run
-    /// let s = [1, 2, 3, 4, 5];
-    /// let s2: Vec<isize> = s[..].iter().cloned().collect();
+    /// let some_vec = vec![0, 1, 2, 3];
+    /// let bad_vec = some_vec.iter().nth(3);
+    /// let bad_slice = &some_vec[..].iter().nth(3);
     /// ```
-    /// The better use would be:
+    /// The correct use would be:
     /// ```no_run
-    /// let s = [1, 2, 3, 4, 5];
-    /// let s2: Vec<isize> = s.to_vec();
+    /// let some_vec = vec![0, 1, 2, 3];
+    /// let bad_vec = some_vec.get(3);
+    /// let bad_slice = &some_vec[..].get(3);
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub ITER_CLONED_COLLECT,
+    pub ITER_NTH,
     style,
-    "using `.cloned().collect()` on slice to create a `Vec`"
+    "using `.iter().nth()` on a standard library type with O(1) element access"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.chars().last()` or
-    /// `_.chars().next_back()` on a `str` to check if it ends with a given char.
+    /// Checks for the use of `iter.nth(0)`.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.ends_with(_)`.
+    /// `iter.next()` is equivalent to
+    /// `iter.nth(0)`, as they both consume the next element,
+    ///  but is more readable.
     ///
     /// ### Example
     /// ```no_run
-    /// # let name = "_";
-    /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-');
+    /// # use std::collections::HashSet;
+    /// # let mut s = HashSet::new();
+    /// # s.insert(1);
+    /// let x = s.iter().nth(0);
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # let name = "_";
-    /// name.ends_with('_') || name.ends_with('-');
+    /// # use std::collections::HashSet;
+    /// # let mut s = HashSet::new();
+    /// # s.insert(1);
+    /// let x = s.iter().next();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub CHARS_LAST_CMP,
+    #[clippy::version = "1.42.0"]
+    pub ITER_NTH_ZERO,
     style,
-    "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char"
+    "replace `iter.nth(0)` with `iter.next()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.as_ref()` or `.as_mut()` where the
-    /// types before and after the call are the same.
+    ///
+    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on empty collections
     ///
     /// ### Why is this bad?
-    /// The call is unnecessary.
+    ///
+    /// It is simpler to use the empty function from the standard library:
     ///
     /// ### Example
+    ///
     /// ```no_run
-    /// # fn do_stuff(x: &[i32]) {}
-    /// let x: &[i32] = &[1, 2, 3, 4, 5];
-    /// do_stuff(x.as_ref());
+    /// use std::{slice, option};
+    /// let a: slice::Iter<i32> = [].iter();
+    /// let f: option::IntoIter<i32> = None.into_iter();
     /// ```
-    /// The correct use would be:
+    /// Use instead:
     /// ```no_run
-    /// # fn do_stuff(x: &[i32]) {}
-    /// let x: &[i32] = &[1, 2, 3, 4, 5];
-    /// do_stuff(x);
+    /// use std::iter;
+    /// let a: iter::Empty<i32> = iter::empty();
+    /// let b: iter::Empty<i32> = iter::empty();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub USELESS_ASREF,
-    complexity,
-    "using `as_ref` where the types before and after the call are the same"
+    ///
+    /// ### Known problems
+    ///
+    /// The type of the resulting iterator might become incompatible with its usage
+    #[clippy::version = "1.65.0"]
+    pub ITER_ON_EMPTY_COLLECTIONS,
+    nursery,
+    "Iterator for empty array"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `fold` when a more succinct alternative exists.
-    /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`,
-    /// `sum` or `product`.
+    ///
+    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on collections containing a single item
     ///
     /// ### Why is this bad?
-    /// Readability.
+    ///
+    /// It is simpler to use the once function from the standard library:
     ///
     /// ### Example
+    ///
     /// ```no_run
-    /// (0..3).fold(false, |acc, x| acc || x > 2);
+    /// let a = [123].iter();
+    /// let b = Some(123).into_iter();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// (0..3).any(|x| x > 2);
+    /// use std::iter;
+    /// let a = iter::once(&123);
+    /// let b = iter::once(123);
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub UNNECESSARY_FOLD,
-    style,
-    "using `fold` when a more succinct alternative exists"
+    ///
+    /// ### Known problems
+    ///
+    /// The type of the resulting iterator might become incompatible with its usage
+    #[clippy::version = "1.65.0"]
+    pub ITER_ON_SINGLE_ITEMS,
+    nursery,
+    "Iterator for array of length 1"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `filter_map` calls that could be replaced by `filter` or `map`.
-    /// More specifically it checks if the closure provided is only performing one of the
-    /// filter or map operations and suggests the appropriate option.
+    /// Looks for iterator combinator calls such as `.take(x)` or `.skip(x)`
+    /// where `x` is greater than the amount of items that an iterator will produce.
     ///
     /// ### Why is this bad?
-    /// Complexity. The intent is also clearer if only a single
-    /// operation is being performed.
+    /// Taking or skipping more items than there are in an iterator either creates an iterator
+    /// with all items from the original iterator or an iterator with no items at all.
+    /// This is most likely not what the user intended to do.
     ///
     /// ### Example
     /// ```no_run
-    /// let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });
-    ///
-    /// // As there is no transformation of the argument this could be written as:
-    /// let _ = (0..3).filter(|&x| x > 2);
+    /// for _ in [1, 2, 3].iter().take(4) {}
     /// ```
-    ///
+    /// Use instead:
     /// ```no_run
-    /// let _ = (0..4).filter_map(|x| Some(x + 1));
-    ///
-    /// // As there is no conditional check on the argument this could be written as:
-    /// let _ = (0..4).map(|x| x + 1);
+    /// for _ in [1, 2, 3].iter() {}
     /// ```
-    #[clippy::version = "1.31.0"]
-    pub UNNECESSARY_FILTER_MAP,
-    complexity,
-    "using `filter_map` when a more succinct alternative exists"
+    #[clippy::version = "1.74.0"]
+    pub ITER_OUT_OF_BOUNDS,
+    suspicious,
+    "calls to `.take()` or `.skip()` that are out of bounds"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `find_map` calls that could be replaced by `find` or `map`. More
-    /// specifically it checks if the closure provided is only performing one of the
-    /// find or map operations and suggests the appropriate option.
+    /// Checks for usage of `_.cloned().<func>()` where call to `.cloned()` can be postponed.
     ///
     /// ### Why is this bad?
-    /// Complexity. The intent is also clearer if only a single
-    /// operation is being performed.
+    /// It's often inefficient to clone all elements of an iterator, when eventually, only some
+    /// of them will be consumed.
     ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = (0..3).find_map(|x| if x > 2 { Some(x) } else { None });
+    /// ### Known Problems
+    /// This `lint` removes the side of effect of cloning items in the iterator.
+    /// A code that relies on that side-effect could fail.
     ///
-    /// // As there is no transformation of the argument this could be written as:
-    /// let _ = (0..3).find(|&x| x > 2);
+    /// ### Examples
+    /// ```no_run
+    /// # let vec = vec!["string".to_string()];
+    /// vec.iter().cloned().take(10);
+    /// vec.iter().cloned().last();
     /// ```
     ///
+    /// Use instead:
     /// ```no_run
-    /// let _ = (0..4).find_map(|x| Some(x + 1));
-    ///
-    /// // As there is no conditional check on the argument this could be written as:
-    /// let _ = (0..4).map(|x| x + 1).next();
+    /// # let vec = vec!["string".to_string()];
+    /// vec.iter().take(10).cloned();
+    /// vec.iter().last().cloned();
     /// ```
-    #[clippy::version = "1.61.0"]
-    pub UNNECESSARY_FIND_MAP,
-    complexity,
-    "using `find_map` when a more succinct alternative exists"
+    #[clippy::version = "1.60.0"]
+    pub ITER_OVEREAGER_CLONED,
+    perf,
+    "using `cloned()` early with `Iterator::iter()` can lead to some performance inefficiencies"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `into_iter` calls on references which should be replaced by `iter`
-    /// or `iter_mut`.
+    /// Checks for usage of `.skip(x).next()` on iterators.
     ///
     /// ### Why is this bad?
-    /// Readability. Calling `into_iter` on a reference will not move out its
-    /// content into the resulting iterator, which is confusing. It is better just call `iter` or
-    /// `iter_mut` directly.
+    /// `.nth(x)` is cleaner
     ///
     /// ### Example
     /// ```no_run
-    /// # let vec = vec![3, 4, 5];
-    /// (&vec).into_iter();
+    /// let some_vec = vec![0, 1, 2, 3];
+    /// let bad_vec = some_vec.iter().skip(3).next();
+    /// let bad_slice = &some_vec[..].iter().skip(3).next();
     /// ```
-    ///
-    /// Use instead:
+    /// The correct use would be:
     /// ```no_run
-    /// # let vec = vec![3, 4, 5];
-    /// (&vec).iter();
+    /// let some_vec = vec![0, 1, 2, 3];
+    /// let bad_vec = some_vec.iter().nth(3);
+    /// let bad_slice = &some_vec[..].iter().nth(3);
     /// ```
-    #[clippy::version = "1.32.0"]
-    pub INTO_ITER_ON_REF,
+    #[clippy::version = "pre 1.29.0"]
+    pub ITER_SKIP_NEXT,
     style,
-    "using `.into_iter()` on a reference"
+    "using `.skip(x).next()` on an iterator"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `map` followed by a `count`.
+    /// Checks for usage of `.skip(0)` on iterators.
     ///
     /// ### Why is this bad?
-    /// It looks suspicious. Maybe `map` was confused with `filter`.
-    /// If the `map` call is intentional, this should be rewritten
-    /// using `inspect`. Or, if you intend to drive the iterator to
-    /// completion, you can just use `for_each` instead.
+    /// This was likely intended to be `.skip(1)` to skip the first element, as `.skip(0)` does
+    /// nothing. If not, the call should be removed.
     ///
     /// ### Example
     /// ```no_run
-    /// let _ = (0..3).map(|x| x + 2).count();
+    /// let v = vec![1, 2, 3];
+    /// let x = v.iter().skip(0).collect::<Vec<_>>();
+    /// let y = v.iter().collect::<Vec<_>>();
+    /// assert_eq!(x, y);
     /// ```
-    #[clippy::version = "1.39.0"]
-    pub SUSPICIOUS_MAP,
-    suspicious,
-    "suspicious usage of map"
+    #[clippy::version = "1.73.0"]
+    pub ITER_SKIP_ZERO,
+    correctness,
+    "disallows `.skip(0)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `MaybeUninit::uninit().assume_init()`.
+    /// Checks for usage of `.drain(..)` on `Vec` and `VecDeque` for iteration.
     ///
     /// ### Why is this bad?
-    /// For most types, this is undefined behavior.
-    ///
-    /// ### Known problems
-    /// For now, we accept empty tuples and tuples / arrays
-    /// of `MaybeUninit`. There may be other types that allow uninitialized
-    /// data, but those are not yet rigorously defined.
+    /// `.into_iter()` is simpler with better performance.
     ///
     /// ### Example
     /// ```no_run
-    /// // Beware the UB
-    /// use std::mem::MaybeUninit;
-    ///
-    /// let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
+    /// # use std::collections::HashSet;
+    /// let mut foo = vec![0, 1, 2, 3];
+    /// let bar: HashSet<usize> = foo.drain(..).collect();
     /// ```
-    ///
-    /// Note that the following is OK:
-    ///
+    /// Use instead:
     /// ```no_run
-    /// use std::mem::MaybeUninit;
+    /// # use std::collections::HashSet;
+    /// let foo = vec![0, 1, 2, 3];
+    /// let bar: HashSet<usize> = foo.into_iter().collect();
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub ITER_WITH_DRAIN,
+    nursery,
+    "replace `.drain(..)` with `.into_iter()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calling `.step_by(0)` on iterators which panics.
     ///
-    /// let _: [MaybeUninit<bool>; 5] = unsafe {
-    ///     MaybeUninit::uninit().assume_init()
-    /// };
+    /// ### Why is this bad?
+    /// This very much looks like an oversight. Use `panic!()` instead if you
+    /// actually intend to panic.
+    ///
+    /// ### Example
+    /// ```rust,should_panic
+    /// for x in (0..100).step_by(0) {
+    ///     //..
+    /// }
     /// ```
-    #[clippy::version = "1.39.0"]
-    pub UNINIT_ASSUMED_INIT,
+    #[clippy::version = "pre 1.29.0"]
+    pub ITERATOR_STEP_BY_ZERO,
     correctness,
-    "`MaybeUninit::uninit().assume_init()`"
+    "using `Iterator::step_by(0)`, which will panic at runtime"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.
+    /// Checks for calls to `Path::join` that start with a path separator (`\\` or `/`).
     ///
     /// ### Why is this bad?
-    /// These can be written simply with `saturating_add/sub` methods.
+    /// If the argument to `Path::join` starts with a separator, it will overwrite
+    /// the original path. If this is intentional, prefer using `Path::new` instead.
+    ///
+    /// Note the behavior is platform dependent. A leading `\\` will be accepted
+    /// on unix systems as part of the file name
+    ///
+    /// See [`Path::join`](https://doc.rust-lang.org/std/path/struct.Path.html#method.join)
     ///
     /// ### Example
-    /// ```no_run
-    /// # let y: u32 = 0;
-    /// # let x: u32 = 100;
-    /// let add = x.checked_add(y).unwrap_or(u32::MAX);
-    /// let sub = x.checked_sub(y).unwrap_or(u32::MIN);
+    /// ```rust
+    /// # use std::path::{Path, PathBuf};
+    /// let path = Path::new("/bin");
+    /// let joined_path = path.join("/sh");
+    /// assert_eq!(joined_path, PathBuf::from("/sh"));
     /// ```
     ///
-    /// can be written using dedicated methods for saturating addition/subtraction as:
+    /// Use instead;
+    /// ```rust
+    /// # use std::path::{Path, PathBuf};
+    /// let path = Path::new("/bin");
     ///
-    /// ```no_run
-    /// # let y: u32 = 0;
-    /// # let x: u32 = 100;
-    /// let add = x.saturating_add(y);
-    /// let sub = x.saturating_sub(y);
+    /// // If this was unintentional, remove the leading separator
+    /// let joined_path = path.join("sh");
+    /// assert_eq!(joined_path, PathBuf::from("/bin/sh"));
+    ///
+    /// // If this was intentional, create a new path instead
+    /// let new = Path::new("/sh");
+    /// assert_eq!(new, PathBuf::from("/sh"));
     /// ```
-    #[clippy::version = "1.39.0"]
-    pub MANUAL_SATURATING_ARITHMETIC,
-    style,
-    "`.checked_add/sub(x).unwrap_or(MAX/MIN)`"
+    #[clippy::version = "1.76.0"]
+    pub JOIN_ABSOLUTE_PATHS,
+    suspicious,
+    "calls to `Path::join` which will overwrite the original path"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to
-    /// zero-sized types
+    /// Checks for usage of `lines.filter_map(Result::ok)` or `lines.flat_map(Result::ok)`
+    /// when `lines` has type `std::io::Lines`.
     ///
     /// ### Why is this bad?
-    /// This is a no-op, and likely unintended
+    /// `Lines` instances might produce a never-ending stream of `Err`, in which case
+    /// `filter_map(Result::ok)` will enter an infinite loop while waiting for an
+    /// `Ok` variant. Calling `next()` once is sufficient to enter the infinite loop,
+    /// even in the absence of explicit loops in the user code.
+    ///
+    /// This situation can arise when working with user-provided paths. On some platforms,
+    /// `std::fs::File::open(path)` might return `Ok(fs)` even when `path` is a directory,
+    /// but any later attempt to read from `fs` will return an error.
+    ///
+    /// ### Known problems
+    /// This lint suggests replacing `filter_map()` or `flat_map()` applied to a `Lines`
+    /// instance in all cases. There are two cases where the suggestion might not be
+    /// appropriate or necessary:
+    ///
+    /// - If the `Lines` instance can never produce any error, or if an error is produced
+    ///   only once just before terminating the iterator, using `map_while()` is not
+    ///   necessary but will not do any harm.
+    /// - If the `Lines` instance can produce intermittent errors then recover and produce
+    ///   successful results, using `map_while()` would stop at the first error.
     ///
     /// ### Example
     /// ```no_run
-    /// unsafe { (&() as *const ()).offset(1) };
+    /// # use std::{fs::File, io::{self, BufRead, BufReader}};
+    /// # let _ = || -> io::Result<()> {
+    /// let mut lines = BufReader::new(File::open("some-path")?).lines().filter_map(Result::ok);
+    /// // If "some-path" points to a directory, the next statement never terminates:
+    /// let first_line: Option<String> = lines.next();
+    /// # Ok(()) };
     /// ```
-    #[clippy::version = "1.41.0"]
-    pub ZST_OFFSET,
-    correctness,
-    "Check for offset calculations on raw pointers to zero-sized types"
+    /// Use instead:
+    /// ```no_run
+    /// # use std::{fs::File, io::{self, BufRead, BufReader}};
+    /// # let _ = || -> io::Result<()> {
+    /// let mut lines = BufReader::new(File::open("some-path")?).lines().map_while(Result::ok);
+    /// let first_line: Option<String> = lines.next();
+    /// # Ok(()) };
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub LINES_FILTER_MAP_OK,
+    suspicious,
+    "filtering `std::io::Lines` with `filter_map()`, `flat_map()`, or `flatten()` might cause an infinite loop"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of the `offset` pointer method with an integer
-    /// literal.
+    /// Checks for the manual creation of C strings (a string with a `NUL` byte at the end), either
+    /// through one of the `CStr` constructor functions, or more plainly by calling `.as_ptr()`
+    /// on a (byte) string literal with a hardcoded `\0` byte at the end.
     ///
     /// ### Why is this bad?
-    /// The `add` and `sub` methods more accurately express the intent.
+    /// This can be written more concisely using `c"str"` literals and is also less error-prone,
+    /// because the compiler checks for interior `NUL` bytes and the terminating `NUL` byte is inserted automatically.
     ///
     /// ### Example
     /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
+    /// # use std::ffi::CStr;
+    /// # mod libc { pub unsafe fn puts(_: *const i8) {} }
+    /// fn needs_cstr(_: &CStr) {}
     ///
-    /// unsafe {
-    ///     ptr.offset(-8);
-    /// }
+    /// needs_cstr(CStr::from_bytes_with_nul(b"Hello\0").unwrap());
+    /// unsafe { libc::puts("World\0".as_ptr().cast()) }
     /// ```
-    ///
-    /// Could be written:
-    ///
+    /// Use instead:
     /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
+    /// # use std::ffi::CStr;
+    /// # mod libc { pub unsafe fn puts(_: *const i8) {} }
+    /// fn needs_cstr(_: &CStr) {}
     ///
-    /// unsafe {
-    ///     ptr.sub(8);
-    /// }
+    /// needs_cstr(c"Hello");
+    /// unsafe { libc::puts(c"World".as_ptr()) }
     /// ```
-    #[clippy::version = "1.92.0"]
-    pub PTR_OFFSET_BY_LITERAL,
-    pedantic,
-    "unneeded pointer offset"
+    #[clippy::version = "1.78.0"]
+    pub MANUAL_C_STR_LITERALS,
+    complexity,
+    r#"creating a `CStr` through functions when `c""` literals can be used"#
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of the `offset` pointer method with a `usize` casted to an
-    /// `isize`.
+    /// Checks for usage of `iter().any()` on slices when it can be replaced with `contains()` and suggests doing so.
     ///
     /// ### Why is this bad?
-    /// If we’re always increasing the pointer address, we can avoid the numeric
-    /// cast by using the `add` method instead.
+    /// `contains()` is more concise and idiomatic, while also being faster in some cases.
     ///
     /// ### Example
     /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
-    /// let offset = 1_usize;
-    ///
-    /// unsafe {
-    ///     ptr.offset(offset as isize);
+    /// fn foo(values: &[u8]) -> bool {
+    ///     values.iter().any(|&v| v == 10)
     /// }
     /// ```
-    ///
-    /// Could be written:
-    ///
+    /// Use instead:
     /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
-    /// let offset = 1_usize;
-    ///
-    /// unsafe {
-    ///     ptr.add(offset);
+    /// fn foo(values: &[u8]) -> bool {
+    ///     values.contains(&10)
     /// }
     /// ```
-    #[clippy::version = "1.30.0"]
-    pub PTR_OFFSET_WITH_CAST,
-    complexity,
-    "unneeded pointer offset cast"
+    #[clippy::version = "1.87.0"]
+    pub MANUAL_CONTAINS,
+    perf,
+    "unnecessary `iter().any()` on slices that can be replaced with `contains()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `FileType::is_file()`.
+    /// Checks for usage of `_.filter(_).map(_)` that can be written more simply
+    /// as `filter_map(_)`.
     ///
-    /// ### Why restrict this?
-    /// When people testing a file type with `FileType::is_file`
-    /// they are testing whether a path is something they can get bytes from. But
-    /// `is_file` doesn't cover special file types in unix-like systems, and doesn't cover
-    /// symlink in windows. Using `!FileType::is_dir()` is a better way to that intention.
+    /// ### Why is this bad?
+    /// Redundant code in the `filter` and `map` operations is poor style and
+    /// less performant.
     ///
-    /// ### Example
+     /// ### Example
     /// ```no_run
-    /// # || {
-    /// let metadata = std::fs::metadata("foo.txt")?;
-    /// let filetype = metadata.file_type();
+    /// (0_i32..10)
+    ///     .filter(|n| n.checked_add(1).is_some())
+    ///     .map(|n| n.checked_add(1).unwrap());
+    /// ```
     ///
-    /// if filetype.is_file() {
-    ///     // read file
-    /// }
-    /// # Ok::<_, std::io::Error>(())
-    /// # };
+    /// Use instead:
+    /// ```no_run
+    /// (0_i32..10).filter_map(|n| n.checked_add(1));
     /// ```
+    #[clippy::version = "1.51.0"]
+    pub MANUAL_FILTER_MAP,
+    complexity,
+    "using `_.filter(_).map(_)` in a way that can be written more simply as `filter_map(_)`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.find(_).map(_)` that can be written more simply
+    /// as `find_map(_)`.
     ///
-    /// should be written as:
+    /// ### Why is this bad?
+    /// Redundant code in the `find` and `map` operations is poor style and
+    /// less performant.
     ///
+     /// ### Example
     /// ```no_run
-    /// # || {
-    /// let metadata = std::fs::metadata("foo.txt")?;
-    /// let filetype = metadata.file_type();
+    /// (0_i32..10)
+    ///     .find(|n| n.checked_add(1).is_some())
+    ///     .map(|n| n.checked_add(1).unwrap());
+    /// ```
     ///
-    /// if !filetype.is_dir() {
-    ///     // read file
-    /// }
-    /// # Ok::<_, std::io::Error>(())
-    /// # };
+    /// Use instead:
+    /// ```no_run
+    /// (0_i32..10).find_map(|n| n.checked_add(1));
     /// ```
-    #[clippy::version = "1.42.0"]
-    pub FILETYPE_IS_FILE,
-    restriction,
-    "`FileType::is_file` is not recommended to test for readable file type"
+    #[clippy::version = "1.51.0"]
+    pub MANUAL_FIND_MAP,
+    complexity,
+    "using `_.find(_).map(_)` in a way that can be written more simply as `find_map(_)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.as_ref().map(Deref::deref)` or its aliases (such as String::as_str).
+    /// Checks for uses of `map` which return the original item.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.as_deref()`.
+    /// `inspect` is both clearer in intent and shorter.
     ///
     /// ### Example
     /// ```no_run
-    /// # let opt = Some("".to_string());
-    /// opt.as_ref().map(String::as_str)
-    /// # ;
+    /// let x = Some(0).map(|x| { println!("{x}"); x });
     /// ```
-    /// Can be written as
+    /// Use instead:
     /// ```no_run
-    /// # let opt = Some("".to_string());
-    /// opt.as_deref()
-    /// # ;
+    /// let x = Some(0).inspect(|x| println!("{x}"));
     /// ```
-    #[clippy::version = "1.42.0"]
-    pub OPTION_AS_REF_DEREF,
+    #[clippy::version = "1.81.0"]
+    pub MANUAL_INSPECT,
     complexity,
-    "using `as_ref().map(Deref::deref)`, which is more succinctly expressed as `as_deref()`"
+    "use of `map` returning the original item"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `iter().next()` on a Slice or an Array
+    /// Checks for usage of `option.map(f).unwrap_or_default()` and `result.map(f).unwrap_or_default()` where `f` is a function or closure that returns the `bool` type.
+    ///
+    /// Also checks for equality comparisons like `option.map(f) == Some(true)` and `result.map(f) == Ok(true)`.
     ///
     /// ### Why is this bad?
-    /// These can be shortened into `.get()`
+    /// Readability. These can be written more concisely as `option.is_some_and(f)` and `result.is_ok_and(f)`.
     ///
     /// ### Example
     /// ```no_run
-    /// # let a = [1, 2, 3];
-    /// # let b = vec![1, 2, 3];
-    /// a[2..].iter().next();
-    /// b.iter().next();
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.map(|a| a > 10).unwrap_or_default();
+    /// result.map(|a| a > 10).unwrap_or_default();
+    ///
+    /// option.map(|a| a > 10) == Some(true);
+    /// result.map(|a| a > 10) == Ok(true);
+    /// option.map(|a| a > 10) != Some(true);
+    /// result.map(|a| a > 10) != Ok(true);
     /// ```
-    /// should be written as:
+    /// Use instead:
     /// ```no_run
-    /// # let a = [1, 2, 3];
-    /// # let b = vec![1, 2, 3];
-    /// a.get(2);
-    /// b.get(0);
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.is_some_and(|a| a > 10);
+    /// result.is_ok_and(|a| a > 10);
+    ///
+    /// option.is_some_and(|a| a > 10);
+    /// result.is_ok_and(|a| a > 10);
+    /// option.is_none_or(|a| a > 10);
+    /// !result.is_ok_and(|a| a > 10);
     /// ```
-    #[clippy::version = "1.46.0"]
-    pub ITER_NEXT_SLICE,
-    style,
-    "using `.iter().next()` on a sliced array, which can be shortened to just `.get()`"
+    #[clippy::version = "1.77.0"]
+    pub MANUAL_IS_VARIANT_AND,
+    pedantic,
+    "using `.map(f).unwrap_or_default()` or `.map(f) == Some/Ok(true)`, which are more succinctly expressed as `is_some_and(f)` or `is_ok_and(f)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns when using `push_str`/`insert_str` with a single-character string literal
-    /// where `push`/`insert` with a `char` would work fine.
+    /// Checks for `.rev().next()` on a `DoubleEndedIterator`
     ///
     /// ### Why is this bad?
-    /// It's less clear that we are pushing a single character.
+    /// `.next_back()` is cleaner.
     ///
     /// ### Example
     /// ```no_run
-    /// # let mut string = String::new();
-    /// string.insert_str(0, "R");
-    /// string.push_str("R");
+    /// # let foo = [0; 10];
+    /// foo.iter().rev().next();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let mut string = String::new();
-    /// string.insert(0, 'R');
-    /// string.push('R');
+    /// # let foo = [0; 10];
+    /// foo.iter().next_back();
     /// ```
-    #[clippy::version = "1.49.0"]
-    pub SINGLE_CHAR_ADD_STR,
+    #[clippy::version = "1.71.0"]
+    pub MANUAL_NEXT_BACK,
     style,
-    "`push_str()` or `insert_str()` used with a single-character string literal as parameter"
+    "manual reverse iteration of `DoubleEndedIterator`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// As the counterpart to `or_fun_call`, this lint looks for unnecessary
-    /// lazily evaluated closures on `Option` and `Result`.
     ///
-    /// This lint suggests changing the following functions, when eager evaluation results in
-    /// simpler code:
-    ///  - `unwrap_or_else` to `unwrap_or`
-    ///  - `and_then` to `and`
-    ///  - `or_else` to `or`
-    ///  - `get_or_insert_with` to `get_or_insert`
-    ///  - `ok_or_else` to `ok_or`
-    ///  - `then` to `then_some` (for msrv >= 1.62.0)
+    /// Finds patterns that reimplement `Option::ok_or`.
     ///
     /// ### Why is this bad?
-    /// Using eager evaluation is shorter and simpler in some cases.
     ///
-    /// ### Known problems
-    /// It is possible, but not recommended for `Deref` and `Index` to have
-    /// side effects. Eagerly evaluating them can change the semantics of the program.
+    /// Concise code helps focusing on behavior instead of boilerplate.
     ///
-    /// ### Example
+    /// ### Examples
     /// ```no_run
-    /// let opt: Option<u32> = None;
-    ///
-    /// opt.unwrap_or_else(|| 42);
+    /// let foo: Option<i32> = None;
+    /// foo.map_or(Err("error"), |v| Ok(v));
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let opt: Option<u32> = None;
-    ///
-    /// opt.unwrap_or(42);
+    /// let foo: Option<i32> = None;
+    /// foo.ok_or("error");
     /// ```
-    #[clippy::version = "1.48.0"]
-    pub UNNECESSARY_LAZY_EVALUATIONS,
+    #[clippy::version = "1.49.0"]
+    pub MANUAL_OK_OR,
     style,
-    "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation"
+    "finds patterns that can be encoded more concisely with `Option::ok_or`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.map(_).collect::<Result<(), _>()`.
+    ///
+    /// Checks for `repeat().take()` that can be replaced with `repeat_n()`.
     ///
     /// ### Why is this bad?
-    /// Using `try_for_each` instead is more readable and idiomatic.
+    ///
+    /// Using `repeat_n()` is more concise and clearer. Also, `repeat_n()` is sometimes faster than `repeat().take()` when the type of the element is non-trivial to clone because the original value can be reused for the last `.next()` call rather than always cloning.
     ///
     /// ### Example
     /// ```no_run
-    /// (0..3).map(|t| Err(t)).collect::<Result<(), _>>();
+    /// let _ = std::iter::repeat(10).take(3);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// (0..3).try_for_each(|t| Err(t));
+    /// let _ = std::iter::repeat_n(10, 3);
     /// ```
-    #[clippy::version = "1.49.0"]
-    pub MAP_COLLECT_RESULT_UNIT,
+    #[clippy::version = "1.86.0"]
+    pub MANUAL_REPEAT_N,
     style,
-    "using `.map(_).collect::<Result<(),_>()`, which can be replaced with `try_for_each`"
+    "detect `repeat().take()` that can be replaced with `repeat_n()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `from_iter()` function calls on types that implement the `FromIterator`
-    /// trait.
+    /// Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.
     ///
     /// ### Why is this bad?
-    /// If it's needed to create a collection from the contents of an iterator, the `Iterator::collect(_)`
-    /// method is preferred. However, when it's needed to specify the container type,
-    /// `Vec::from_iter(_)` can be more readable than using a turbofish (e.g. `_.collect::<Vec<_>>()`). See
-    /// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)
+    /// These can be written simply with `saturating_add/sub` methods.
     ///
     /// ### Example
     /// ```no_run
-    /// let five_fives = std::iter::repeat(5).take(5);
-    ///
-    /// let v = Vec::from_iter(five_fives);
-    ///
-    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
+    /// # let y: u32 = 0;
+    /// # let x: u32 = 100;
+    /// let add = x.checked_add(y).unwrap_or(u32::MAX);
+    /// let sub = x.checked_sub(y).unwrap_or(u32::MIN);
     /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let five_fives = std::iter::repeat(5).take(5);
     ///
-    /// let v: Vec<i32> = five_fives.collect();
+    /// can be written using dedicated methods for saturating addition/subtraction as:
     ///
-    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
-    /// ```
-    /// but prefer to use
-    /// ```no_run
-    /// let numbers: Vec<i32> = FromIterator::from_iter(1..=5);
-    /// ```
-    /// instead of
     /// ```no_run
-    /// let numbers = (1..=5).collect::<Vec<_>>();
+    /// # let y: u32 = 0;
+    /// # let x: u32 = 100;
+    /// let add = x.saturating_add(y);
+    /// let sub = x.saturating_sub(y);
     /// ```
-    #[clippy::version = "1.49.0"]
-    pub FROM_ITER_INSTEAD_OF_COLLECT,
-    pedantic,
-    "use `.collect()` instead of `::from_iter()`"
+    #[clippy::version = "1.39.0"]
+    pub MANUAL_SATURATING_ARITHMETIC,
+    style,
+    "`.checked_add/sub(x).unwrap_or(MAX/MIN)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `inspect().for_each()`.
+    /// Checks for usage of `str::splitn(2, _)`
     ///
     /// ### Why is this bad?
-    /// It is the same as performing the computation
-    /// inside `inspect` at the beginning of the closure in `for_each`.
+    /// `split_once` is both clearer in intent and slightly more efficient.
     ///
     /// ### Example
-    /// ```no_run
-    /// [1,2,3,4,5].iter()
-    /// .inspect(|&x| println!("inspect the number: {}", x))
-    /// .for_each(|&x| {
-    ///     assert!(x >= 0);
-    /// });
-    /// ```
-    /// Can be written as
-    /// ```no_run
-    /// [1,2,3,4,5].iter()
-    /// .for_each(|&x| {
-    ///     println!("inspect the number: {}", x);
-    ///     assert!(x >= 0);
-    /// });
-    /// ```
-    #[clippy::version = "1.51.0"]
-    pub INSPECT_FOR_EACH,
-    complexity,
-    "using `.inspect().for_each()`, which can be replaced with `.for_each()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `filter_map(|x| x)`.
-    ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely by using `flatten`.
+    /// ```rust,ignore
+    /// let s = "key=value=add";
+    /// let (key, value) = s.splitn(2, '=').next_tuple()?;
+    /// let value = s.splitn(2, '=').nth(1)?;
     ///
-    /// ### Example
-    /// ```no_run
-    /// # let iter = vec![Some(1)].into_iter();
-    /// iter.filter_map(|x| x);
+    /// let mut parts = s.splitn(2, '=');
+    /// let key = parts.next()?;
+    /// let value = parts.next()?;
     /// ```
+    ///
     /// Use instead:
-    /// ```no_run
-    /// # let iter = vec![Some(1)].into_iter();
-    /// iter.flatten();
+    /// ```rust,ignore
+    /// let s = "key=value=add";
+    /// let (key, value) = s.split_once('=')?;
+    /// let value = s.split_once('=')?.1;
+    ///
+    /// let (key, value) = s.split_once('=')?;
     /// ```
-    #[clippy::version = "1.52.0"]
-    pub FILTER_MAP_IDENTITY,
+    ///
+    /// ### Limitations
+    /// The multiple statement variant currently only detects `iter.next()?`/`iter.next().unwrap()`
+    /// in two separate `let` statements that immediately follow the `splitn()`
+    #[clippy::version = "1.57.0"]
+    pub MANUAL_SPLIT_ONCE,
     complexity,
-    "call to `filter_map` where `flatten` is sufficient"
+    "replace `.splitn(2, pat)` with `.split_once(pat)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for instances of `map(f)` where `f` is the identity function.
+    /// Checks for manual implementations of `str::repeat`
     ///
     /// ### Why is this bad?
-    /// It can be written more concisely without the call to `map`.
+    /// These are both harder to read, as well as less performant.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = [1, 2, 3];
-    /// let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();
+    /// let x: String = std::iter::repeat('x').take(10).collect();
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let x = [1, 2, 3];
-    /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
+    /// let x: String = "x".repeat(10);
     /// ```
-    #[clippy::version = "1.47.0"]
-    pub MAP_IDENTITY,
-    complexity,
-    "using iterator.map(|x| x)"
+    #[clippy::version = "1.54.0"]
+    pub MANUAL_STR_REPEAT,
+    perf,
+    "manual implementation of `str::repeat`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the use of `.bytes().nth()`.
+    /// Checks for usage of `Iterator::fold` with a type that implements `Try`.
     ///
     /// ### Why is this bad?
-    /// `.as_bytes().get()` is more efficient and more
-    /// readable.
+    /// The code should use `try_fold` instead, which short-circuits on failure, thus opening the
+    /// door for additional optimizations not possible with `fold` as rustc can guarantee the
+    /// function is never called on `None`, `Err`, etc., alleviating otherwise necessary checks. It's
+    /// also slightly more idiomatic.
+    ///
+    /// ### Known issues
+    /// This lint doesn't take into account whether a function does something on the failure case,
+    /// i.e., whether short-circuiting will affect behavior. Refactoring to `try_fold` is not
+    /// desirable in those cases.
     ///
     /// ### Example
     /// ```no_run
-    /// "Hello".bytes().nth(3);
+    /// vec![1, 2, 3].iter().fold(Some(0i32), |sum, i| sum?.checked_add(*i));
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// "Hello".as_bytes().get(3);
+    /// vec![1, 2, 3].iter().try_fold(0i32, |sum, i| sum.checked_add(*i));
     /// ```
-    #[clippy::version = "1.52.0"]
-    pub BYTES_NTH,
-    style,
-    "replace `.bytes().nth()` with `.as_bytes().get()`"
+    #[clippy::version = "1.72.0"]
+    pub MANUAL_TRY_FOLD,
+    perf,
+    "checks for usage of `Iterator::fold` with a type that implements `Try`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.
+    /// Checks for usage of `.map(…)`, followed by `.all(identity)` or `.any(identity)`.
     ///
     /// ### Why is this bad?
-    /// These methods do the same thing as `_.clone()` but may be confusing as
-    /// to why we are calling `to_vec` on something that is already a `Vec` or calling `to_owned` on something that is already owned.
+    /// The `.all(…)` or `.any(…)` methods can be called directly in place of `.map(…)`.
     ///
     /// ### Example
-    /// ```no_run
-    /// let a = vec![1, 2, 3];
-    /// let b = a.to_vec();
-    /// let c = a.to_owned();
+    /// ```
+    /// # let mut v = [""];
+    /// let e1 = v.iter().map(|s| s.is_empty()).all(|a| a);
+    /// let e2 = v.iter().map(|s| s.is_empty()).any(std::convert::identity);
     /// ```
     /// Use instead:
-    /// ```no_run
-    /// let a = vec![1, 2, 3];
-    /// let b = a.clone();
-    /// let c = a.clone();
     /// ```
-    #[clippy::version = "1.52.0"]
-    pub IMPLICIT_CLONE,
-    pedantic,
-    "implicitly cloning a value by invoking a function on its dereferenced type"
+    /// # let mut v = [""];
+    /// let e1 = v.iter().all(|s| s.is_empty());
+    /// let e2 = v.iter().any(|s| s.is_empty());
+    /// ```
+    #[clippy::version = "1.84.0"]
+    pub MAP_ALL_ANY_IDENTITY,
+    complexity,
+    "combine `.map(_)` followed by `.all(identity)`/`.any(identity)` into a single call"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the use of `.iter().count()`.
+    /// Checks for usage of `map(|x| x.clone())` or
+    /// dereferencing closures for `Copy` types, on `Iterator` or `Option`,
+    /// and suggests `cloned()` or `copied()` instead
     ///
     /// ### Why is this bad?
-    /// `.len()` is more efficient and more
-    /// readable.
+    /// Readability, this can be written more concisely
     ///
     /// ### Example
     /// ```no_run
-    /// let some_vec = vec![0, 1, 2, 3];
-    ///
-    /// some_vec.iter().count();
-    /// &some_vec[..].iter().count();
+    /// let x = vec![42, 43];
+    /// let y = x.iter();
+    /// let z = y.map(|i| *i);
     /// ```
     ///
-    /// Use instead:
-    /// ```no_run
-    /// let some_vec = vec![0, 1, 2, 3];
+    /// The correct use would be:
     ///
-    /// some_vec.len();
-    /// &some_vec[..].len();
+    /// ```no_run
+    /// let x = vec![42, 43];
+    /// let y = x.iter();
+    /// let z = y.cloned();
     /// ```
-    #[clippy::version = "1.52.0"]
-    pub ITER_COUNT,
-    complexity,
-    "replace `.iter().count()` with `.len()`"
+    #[clippy::version = "pre 1.29.0"]
+    pub MAP_CLONE,
+    style,
+    "using `iterator.map(|x| x.clone())`, or dereferencing closures for `Copy` types"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of `_.to_owned()`, on a `Cow<'_, _>`.
+    /// Checks for usage of `_.map(_).collect::<Result<(), _>()`.
     ///
     /// ### Why is this bad?
-    /// Calling `to_owned()` on a `Cow` creates a clone of the `Cow`
-    /// itself, without taking ownership of the `Cow` contents (i.e.
-    /// it's equivalent to calling `Cow::clone`).
-    /// The similarly named `into_owned` method, on the other hand,
-    /// clones the `Cow` contents, effectively turning any `Cow::Borrowed`
-    /// into a `Cow::Owned`.
-    ///
-    /// Given the potential ambiguity, consider replacing `to_owned`
-    /// with `clone` for better readability or, if getting a `Cow::Owned`
-    /// was the original intent, using `into_owned` instead.
+    /// Using `try_for_each` instead is more readable and idiomatic.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::borrow::Cow;
-    /// let s = "Hello world!";
-    /// let cow = Cow::Borrowed(s);
-    ///
-    /// let data = cow.to_owned();
-    /// assert!(matches!(data, Cow::Borrowed(_)))
+    /// (0..3).map(|t| Err(t)).collect::<Result<(), _>>();
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # use std::borrow::Cow;
-    /// let s = "Hello world!";
-    /// let cow = Cow::Borrowed(s);
-    ///
-    /// let data = cow.clone();
-    /// assert!(matches!(data, Cow::Borrowed(_)))
-    /// ```
-    /// or
-    /// ```no_run
-    /// # use std::borrow::Cow;
-    /// let s = "Hello world!";
-    /// let cow = Cow::Borrowed(s);
-    ///
-    /// let _data: String = cow.into_owned();
+    /// (0..3).try_for_each(|t| Err(t));
     /// ```
-    #[clippy::version = "1.65.0"]
-    pub SUSPICIOUS_TO_OWNED,
-    suspicious,
-    "calls to `to_owned` on a `Cow<'_, _>` might not do what they are expected"
+    #[clippy::version = "1.49.0"]
+    pub MAP_COLLECT_RESULT_UNIT,
+    style,
+    "using `.map(_).collect::<Result<(),_>()`, which can be replaced with `try_for_each`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to [`splitn`]
-    /// (https://doc.rust-lang.org/std/primitive.str.html#method.splitn) and
-    /// related functions with either zero or one splits.
+    /// Checks for instances of `map_err(|_| Some::Enum)`
     ///
-    /// ### Why is this bad?
-    /// These calls don't actually split the value and are
-    /// likely to be intended as a different number.
+    /// ### Why restrict this?
+    /// This `map_err` throws away the original error rather than allowing the enum to
+    /// contain and report the cause of the error.
     ///
     /// ### Example
+    /// Before:
     /// ```no_run
-    /// # let s = "";
-    /// for x in s.splitn(1, ":") {
-    ///     // ..
+    /// use std::fmt;
+    ///
+    /// #[derive(Debug)]
+    /// enum Error {
+    ///     Indivisible,
+    ///     Remainder(u8),
     /// }
-    /// ```
     ///
-    /// Use instead:
-    /// ```no_run
-    /// # let s = "";
-    /// for x in s.splitn(2, ":") {
-    ///     // ..
+    /// impl fmt::Display for Error {
+    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         match self {
+    ///             Error::Indivisible => write!(f, "could not divide input by three"),
+    ///             Error::Remainder(remainder) => write!(
+    ///                 f,
+    ///                 "input is not divisible by three, remainder = {}",
+    ///                 remainder
+    ///             ),
+    ///         }
+    ///     }
     /// }
-    /// ```
-    #[clippy::version = "1.54.0"]
-    pub SUSPICIOUS_SPLITN,
-    correctness,
-    "checks for `.splitn(0, ..)` and `.splitn(1, ..)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementations of `str::repeat`
     ///
-    /// ### Why is this bad?
-    /// These are both harder to read, as well as less performant.
+    /// impl std::error::Error for Error {}
     ///
-    /// ### Example
-    /// ```no_run
-    /// let x: String = std::iter::repeat('x').take(10).collect();
+    /// fn divisible_by_3(input: &str) -> Result<(), Error> {
+    ///     input
+    ///         .parse::<i32>()
+    ///         .map_err(|_| Error::Indivisible)
+    ///         .map(|v| v % 3)
+    ///         .and_then(|remainder| {
+    ///             if remainder == 0 {
+    ///                 Ok(())
+    ///             } else {
+    ///                 Err(Error::Remainder(remainder as u8))
+    ///             }
+    ///         })
+    /// }
     /// ```
     ///
-    /// Use instead:
-    /// ```no_run
-    /// let x: String = "x".repeat(10);
+    /// After:
+    /// ```rust
+    /// use std::{fmt, num::ParseIntError};
+    ///
+    /// #[derive(Debug)]
+    /// enum Error {
+    ///     Indivisible(ParseIntError),
+    ///     Remainder(u8),
+    /// }
+    ///
+    /// impl fmt::Display for Error {
+    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         match self {
+    ///             Error::Indivisible(_) => write!(f, "could not divide input by three"),
+    ///             Error::Remainder(remainder) => write!(
+    ///                 f,
+    ///                 "input is not divisible by three, remainder = {}",
+    ///                 remainder
+    ///             ),
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// impl std::error::Error for Error {
+    ///     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+    ///         match self {
+    ///             Error::Indivisible(source) => Some(source),
+    ///             _ => None,
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// fn divisible_by_3(input: &str) -> Result<(), Error> {
+    ///     input
+    ///         .parse::<i32>()
+    ///         .map_err(Error::Indivisible)
+    ///         .map(|v| v % 3)
+    ///         .and_then(|remainder| {
+    ///             if remainder == 0 {
+    ///                 Ok(())
+    ///             } else {
+    ///                 Err(Error::Remainder(remainder as u8))
+    ///             }
+    ///         })
+    /// }
     /// ```
-    #[clippy::version = "1.54.0"]
-    pub MANUAL_STR_REPEAT,
-    perf,
-    "manual implementation of `str::repeat`"
+    #[clippy::version = "1.48.0"]
+    pub MAP_ERR_IGNORE,
+    restriction,
+    "`map_err` should not ignore the original error"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `str::splitn(2, _)`
+    /// Checks for usage of `_.map(_).flatten(_)` on `Iterator` and `Option`
     ///
     /// ### Why is this bad?
-    /// `split_once` is both clearer in intent and slightly more efficient.
+    /// Readability, this can be written more concisely as
+    /// `_.flat_map(_)` for `Iterator` or `_.and_then(_)` for `Option`
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// let s = "key=value=add";
-    /// let (key, value) = s.splitn(2, '=').next_tuple()?;
-    /// let value = s.splitn(2, '=').nth(1)?;
+    /// ```no_run
+    /// let vec = vec![vec![1]];
+    /// let opt = Some(5);
     ///
-    /// let mut parts = s.splitn(2, '=');
-    /// let key = parts.next()?;
-    /// let value = parts.next()?;
+    /// vec.iter().map(|x| x.iter()).flatten();
+    /// opt.map(|x| Some(x * 2)).flatten();
     /// ```
     ///
     /// Use instead:
-    /// ```rust,ignore
-    /// let s = "key=value=add";
-    /// let (key, value) = s.split_once('=')?;
-    /// let value = s.split_once('=')?.1;
-    ///
-    /// let (key, value) = s.split_once('=')?;
+    /// ```no_run
+    /// # let vec = vec![vec![1]];
+    /// # let opt = Some(5);
+    /// vec.iter().flat_map(|x| x.iter());
+    /// opt.and_then(|x| Some(x * 2));
     /// ```
-    ///
-    /// ### Limitations
-    /// The multiple statement variant currently only detects `iter.next()?`/`iter.next().unwrap()`
-    /// in two separate `let` statements that immediately follow the `splitn()`
-    #[clippy::version = "1.57.0"]
-    pub MANUAL_SPLIT_ONCE,
+    #[clippy::version = "1.31.0"]
+    pub MAP_FLATTEN,
     complexity,
-    "replace `.splitn(2, pat)` with `.split_once(pat)`"
+    "using combinations of `flatten` and `map` which can usually be written as a single method call"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `str::splitn` (or `str::rsplitn`) where using `str::split` would be the same.
+    /// Checks for instances of `map(f)` where `f` is the identity function.
+    ///
     /// ### Why is this bad?
-    /// The function `split` is simpler and there is no performance difference in these cases, considering
-    /// that both functions return a lazy iterator.
+    /// It can be written more concisely without the call to `map`.
+    ///
     /// ### Example
     /// ```no_run
-    /// let str = "key=value=add";
-    /// let _ = str.splitn(3, '=').next().unwrap();
+    /// let x = [1, 2, 3];
+    /// let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// let str = "key=value=add";
-    /// let _ = str.split('=').next().unwrap();
+    /// let x = [1, 2, 3];
+    /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
     /// ```
-    #[clippy::version = "1.59.0"]
-    pub NEEDLESS_SPLITN,
+    #[clippy::version = "1.47.0"]
+    pub MAP_IDENTITY,
     complexity,
-    "usages of `str::splitn` that can be replaced with `str::split`"
+    "using iterator.map(|x| x)"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for unnecessary calls to [`ToOwned::to_owned`](https://doc.rust-lang.org/std/borrow/trait.ToOwned.html#tymethod.to_owned)
-    /// and other `to_owned`-like functions.
+    /// Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or
+    /// `result.map(_).unwrap_or_else(_)`.
     ///
     /// ### Why is this bad?
-    /// The unnecessary calls result in useless allocations.
+    /// Readability, these can be written more concisely (resp.) as
+    /// `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.
     ///
     /// ### Known problems
-    /// `unnecessary_to_owned` can falsely trigger if `IntoIterator::into_iter` is applied to an
-    /// owned copy of a resource and the resource is later used mutably. See
-    /// [#8148](https://github.com/rust-lang/rust-clippy/issues/8148).
+    /// The order of the arguments is not in execution order
     ///
-    /// ### Example
+    /// ### Examples
     /// ```no_run
-    /// let path = std::path::Path::new("x");
-    /// foo(&path.to_string_lossy().to_string());
-    /// fn foo(s: &str) {}
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// # fn some_function(foo: ()) -> usize { 1 }
+    /// option.map(|a| a + 1).unwrap_or(0);
+    /// option.map(|a| a > 10).unwrap_or(false);
+    /// result.map(|a| a + 1).unwrap_or_else(some_function);
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let path = std::path::Path::new("x");
-    /// foo(&path.to_string_lossy());
-    /// fn foo(s: &str) {}
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// # fn some_function(foo: ()) -> usize { 1 }
+    /// option.map_or(0, |a| a + 1);
+    /// option.is_some_and(|a| a > 10);
+    /// result.map_or_else(some_function, |a| a + 1);
     /// ```
-    #[clippy::version = "1.59.0"]
-    pub UNNECESSARY_TO_OWNED,
-    perf,
-    "unnecessary calls to `to_owned`-like functions"
+    #[clippy::version = "1.45.0"]
+    pub MAP_UNWRAP_OR,
+    pedantic,
+    "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.collect::<Vec<String>>().join("")` on iterators.
+    ///
+    /// Checks for `Iterator::map` over ranges without using the parameter which
+    /// could be more clearly expressed using `std::iter::repeat(...).take(...)`
+    /// or `std::iter::repeat_n`.
     ///
     /// ### Why is this bad?
-    /// `.collect::<String>()` is more concise and might be more performant
+    ///
+    /// It expresses the intent more clearly to `take` the correct number of times
+    /// from a generating function than to apply a closure to each number in a
+    /// range only to discard them.
     ///
     /// ### Example
+    ///
     /// ```no_run
-    /// let vector = vec!["hello",  "world"];
-    /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<Vec<String>>().join("");
-    /// println!("{}", output);
+    /// let random_numbers : Vec<_> = (0..10).map(|_| { 3 + 1 }).collect();
     /// ```
-    /// The correct use would be:
+    /// Use instead:
     /// ```no_run
-    /// let vector = vec!["hello",  "world"];
-    /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<String>();
-    /// println!("{}", output);
+    /// let f : Vec<_> = std::iter::repeat( 3 + 1 ).take(10).collect();
     /// ```
-    /// ### Known problems
-    /// While `.collect::<String>()` is sometimes more performant, there are cases where
-    /// using `.collect::<String>()` over `.collect::<Vec<String>>().join("")`
-    /// will prevent loop unrolling and will result in a negative performance impact.
     ///
-    /// Additionally, differences have been observed between aarch64 and x86_64 assembly output,
-    /// with aarch64 tending to producing faster assembly in more cases when using `.collect::<String>()`
-    #[clippy::version = "1.61.0"]
-    pub UNNECESSARY_JOIN,
-    pedantic,
-    "using `.collect::<Vec<String>>().join(\"\")` on an iterator"
+    /// ### Known Issues
+    ///
+    /// This lint may suggest replacing a `Map<Range>` with a `Take<RepeatWith>`.
+    /// The former implements some traits that the latter does not, such as
+    /// `DoubleEndedIterator`.
+    #[clippy::version = "1.84.0"]
+    pub MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
+    restriction,
+    "map of a trivial closure (not dependent on parameter) over a range"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for no-op uses of `Option::{as_deref, as_deref_mut}`,
-    /// for example, `Option<&T>::as_deref()` returns the same type.
+    /// Checks for `&mut Mutex::lock` calls
     ///
     /// ### Why is this bad?
-    /// Redundant code and improving readability.
+    /// `Mutex::lock` is less efficient than
+    /// calling `Mutex::get_mut`. In addition you also have a statically
+    /// guarantee that the mutex isn't locked, instead of just a runtime
+    /// guarantee.
     ///
     /// ### Example
     /// ```no_run
-    /// let a = Some(&1);
-    /// let b = a.as_deref(); // goes from Option<&i32> to Option<&i32>
-    /// ```
+    /// use std::sync::{Arc, Mutex};
+    ///
+    /// let mut value_rc = Arc::new(Mutex::new(42_u8));
+    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
     ///
+    /// let mut value = value_mutex.lock().unwrap();
+    /// *value += 1;
+    /// ```
     /// Use instead:
     /// ```no_run
-    /// let a = Some(&1);
-    /// let b = a;
-    /// ```
-    #[clippy::version = "1.57.0"]
-    pub NEEDLESS_OPTION_AS_DEREF,
-    complexity,
-    "no-op use of `deref` or `deref_mut` method to `Option`."
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds usages of [`char::is_digit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_digit) that
-    /// can be replaced with [`is_ascii_digit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_digit) or
-    /// [`is_ascii_hexdigit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_hexdigit).
+    /// use std::sync::{Arc, Mutex};
     ///
-    /// ### Why is this bad?
-    /// `is_digit(..)` is slower and requires specifying the radix.
+    /// let mut value_rc = Arc::new(Mutex::new(42_u8));
+    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
     ///
-    /// ### Example
-    /// ```no_run
-    /// let c: char = '6';
-    /// c.is_digit(10);
-    /// c.is_digit(16);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let c: char = '6';
-    /// c.is_ascii_digit();
-    /// c.is_ascii_hexdigit();
+    /// let value = value_mutex.get_mut().unwrap();
+    /// *value += 1;
     /// ```
-    #[clippy::version = "1.62.0"]
-    pub IS_DIGIT_ASCII_RADIX,
+    #[clippy::version = "1.49.0"]
+    pub MUT_MUTEX_LOCK,
     style,
-    "use of `char::is_digit(..)` with literal radix of 10 or 16"
+    "`&mut Mutex::lock` does unnecessary locking"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calling `take` function after `as_ref`.
+    /// Checks for naive byte counts
     ///
     /// ### Why is this bad?
-    /// Redundant code. `take` writes `None` to its argument.
-    /// In this case the modification is useless as it's a temporary that cannot be read from afterwards.
+    /// The [`bytecount`](https://crates.io/crates/bytecount)
+    /// crate has methods to count your bytes faster, especially for large slices.
+    ///
+    /// ### Known problems
+    /// If you have predominantly small slices, the
+    /// `bytecount::count(..)` method may actually be slower. However, if you can
+    /// ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be
+    /// faster in those cases.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = Some(3);
-    /// x.as_ref().take();
+    /// # let vec = vec![1_u8];
+    /// let count = vec.iter().filter(|x| **x == 0u8).count();
     /// ```
+    ///
     /// Use instead:
-    /// ```no_run
-    /// let x = Some(3);
-    /// x.as_ref();
+    /// ```rust,ignore
+    /// # let vec = vec![1_u8];
+    /// let count = bytecount::count(&vec, 0u8);
     /// ```
-    #[clippy::version = "1.62.0"]
-    pub NEEDLESS_OPTION_TAKE,
-    complexity,
-    "using `.as_ref().take()` on a temporary value"
+    #[clippy::version = "pre 1.29.0"]
+    pub NAIVE_BYTECOUNT,
+    pedantic,
+    "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
 }
 
 declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `replace` statements which have no effect.
-    ///
-    /// ### Why is this bad?
-    /// It's either a mistake or confusing.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// "1234".replace("12", "12");
-    /// "1234".replacen("12", "12", 1);
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub NO_EFFECT_REPLACE,
-    suspicious,
-    "replace with no effect"
+   /// ### What it does
+   /// It detects useless calls to `str::as_bytes()` before calling `len()` or `is_empty()`.
+   ///
+   /// ### Why is this bad?
+   /// The `len()` and `is_empty()` methods are also directly available on strings, and they
+   /// return identical results. In particular, `len()` on a string returns the number of
+   /// bytes.
+   ///
+   /// ### Example
+   /// ```
+   /// let len = "some string".as_bytes().len();
+   /// let b = "some string".as_bytes().is_empty();
+   /// ```
+   /// Use instead:
+   /// ```
+   /// let len = "some string".len();
+   /// let b = "some string".is_empty();
+   /// ```
+   #[clippy::version = "1.84.0"]
+   pub NEEDLESS_AS_BYTES,
+   complexity,
+   "detect useless calls to `as_bytes()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for unnecessary method chains that can be simplified into `if .. else ..`.
+    /// Checks if an iterator is used to check if a string is ascii.
     ///
     /// ### Why is this bad?
-    /// This can be written more clearly with `if .. else ..`
-    ///
-    /// ### Limitations
-    /// This lint currently only looks for usages of
-    /// `.{then, then_some}(..).{unwrap_or, unwrap_or_else, unwrap_or_default}(..)`, but will be expanded
-    /// to account for similar patterns.
+    /// The `str` type already implements the `is_ascii` method.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = true;
-    /// x.then_some("a").unwrap_or("b");
+    /// "foo".chars().all(|c| c.is_ascii());
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let x = true;
-    /// if x { "a" } else { "b" };
+    /// "foo".is_ascii();
     /// ```
-    #[clippy::version = "1.64.0"]
-    pub OBFUSCATED_IF_ELSE,
-    style,
-    "use of `.then_some(..).unwrap_or(..)` can be written \
-    more clearly with `if .. else ..`"
+    #[clippy::version = "1.81.0"]
+    pub NEEDLESS_CHARACTER_ITERATION,
+    suspicious,
+    "is_ascii() called on a char iterator"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on collections containing a single item
+    /// Checks for functions collecting an iterator when collect
+    /// is not needed.
     ///
     /// ### Why is this bad?
-    ///
-    /// It is simpler to use the once function from the standard library:
+    /// `collect` causes the allocation of a new data structure,
+    /// when this allocation may not be needed.
     ///
     /// ### Example
-    ///
     /// ```no_run
-    /// let a = [123].iter();
-    /// let b = Some(123).into_iter();
+    /// # let iterator = vec![1].into_iter();
+    /// let len = iterator.collect::<Vec<_>>().len();
     /// ```
     /// Use instead:
     /// ```no_run
-    /// use std::iter;
-    /// let a = iter::once(&123);
-    /// let b = iter::once(123);
+    /// # let iterator = vec![1].into_iter();
+    /// let len = iterator.count();
     /// ```
-    ///
-    /// ### Known problems
-    ///
-    /// The type of the resulting iterator might become incompatible with its usage
-    #[clippy::version = "1.65.0"]
-    pub ITER_ON_SINGLE_ITEMS,
+    #[clippy::version = "1.30.0"]
+    pub NEEDLESS_COLLECT,
     nursery,
-    "Iterator for array of length 1"
+    "collecting an iterator when collect is not needed"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on empty collections
+    /// Checks for no-op uses of `Option::{as_deref, as_deref_mut}`,
+    /// for example, `Option<&T>::as_deref()` returns the same type.
     ///
     /// ### Why is this bad?
-    ///
-    /// It is simpler to use the empty function from the standard library:
+    /// Redundant code and improving readability.
     ///
     /// ### Example
-    ///
     /// ```no_run
-    /// use std::{slice, option};
-    /// let a: slice::Iter<i32> = [].iter();
-    /// let f: option::IntoIter<i32> = None.into_iter();
+    /// let a = Some(&1);
+    /// let b = a.as_deref(); // goes from Option<&i32> to Option<&i32>
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// use std::iter;
-    /// let a: iter::Empty<i32> = iter::empty();
-    /// let b: iter::Empty<i32> = iter::empty();
+    /// let a = Some(&1);
+    /// let b = a;
     /// ```
-    ///
-    /// ### Known problems
-    ///
-    /// The type of the resulting iterator might become incompatible with its usage
-    #[clippy::version = "1.65.0"]
-    pub ITER_ON_EMPTY_COLLECTIONS,
-    nursery,
-    "Iterator for empty array"
+    #[clippy::version = "1.57.0"]
+    pub NEEDLESS_OPTION_AS_DEREF,
+    complexity,
+    "no-op use of `deref` or `deref_mut` method to `Option`."
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for naive byte counts
+    /// Checks for calling `take` function after `as_ref`.
     ///
     /// ### Why is this bad?
-    /// The [`bytecount`](https://crates.io/crates/bytecount)
-    /// crate has methods to count your bytes faster, especially for large slices.
-    ///
-    /// ### Known problems
-    /// If you have predominantly small slices, the
-    /// `bytecount::count(..)` method may actually be slower. However, if you can
-    /// ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be
-    /// faster in those cases.
+    /// Redundant code. `take` writes `None` to its argument.
+    /// In this case the modification is useless as it's a temporary that cannot be read from afterwards.
     ///
     /// ### Example
     /// ```no_run
-    /// # let vec = vec![1_u8];
-    /// let count = vec.iter().filter(|x| **x == 0u8).count();
+    /// let x = Some(3);
+    /// x.as_ref().take();
     /// ```
-    ///
     /// Use instead:
-    /// ```rust,ignore
-    /// # let vec = vec![1_u8];
-    /// let count = bytecount::count(&vec, 0u8);
+    /// ```no_run
+    /// let x = Some(3);
+    /// x.as_ref();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NAIVE_BYTECOUNT,
-    pedantic,
-    "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
+    #[clippy::version = "1.62.0"]
+    pub NEEDLESS_OPTION_TAKE,
+    complexity,
+    "using `.as_ref().take()` on a temporary value"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// It checks for `str::bytes().count()` and suggests replacing it with
-    /// `str::len()`.
-    ///
+    /// Checks for usage of `str::splitn` (or `str::rsplitn`) where using `str::split` would be the same.
     /// ### Why is this bad?
-    /// `str::bytes().count()` is longer and may not be as performant as using
-    /// `str::len()`.
-    ///
+    /// The function `split` is simpler and there is no performance difference in these cases, considering
+    /// that both functions return a lazy iterator.
     /// ### Example
     /// ```no_run
-    /// "hello".bytes().count();
-    /// String::from("hello").bytes().count();
+    /// let str = "key=value=add";
+    /// let _ = str.splitn(3, '=').next().unwrap();
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// "hello".len();
-    /// String::from("hello").len();
+    /// let str = "key=value=add";
+    /// let _ = str.split('=').next().unwrap();
     /// ```
-    #[clippy::version = "1.62.0"]
-    pub BYTES_COUNT_TO_LEN,
+    #[clippy::version = "1.59.0"]
+    pub NEEDLESS_SPLITN,
     complexity,
-    "Using `bytes().count()` when `len()` performs the same functionality"
+    "usages of `str::splitn` that can be replaced with `str::split`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `ends_with` with possible file extensions
-    /// and suggests to use a case-insensitive approach instead.
+    /// Checks for `new` not returning a type that contains `Self`.
     ///
     /// ### Why is this bad?
-    /// `ends_with` is case-sensitive and may not detect files with a valid extension.
+    /// As a convention, `new` methods are used to make a new
+    /// instance of a type.
     ///
     /// ### Example
+    /// In an impl block:
     /// ```no_run
-    /// fn is_rust_file(filename: &str) -> bool {
-    ///     filename.ends_with(".rs")
-    /// }
-    /// ```
-    /// Use instead:
+    /// # struct Foo;
+    /// # struct NotAFoo;
+    /// impl Foo {
+    ///     fn new() -> NotAFoo {
+    /// # NotAFoo
+    ///     }
+    /// }
+    /// ```
+    ///
     /// ```no_run
-    /// fn is_rust_file(filename: &str) -> bool {
-    ///     let filename = std::path::Path::new(filename);
-    ///     filename.extension()
-    ///         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
+    /// # struct Foo;
+    /// struct Bar(Foo);
+    /// impl Foo {
+    ///     // Bad. The type name must contain `Self`
+    ///     fn new() -> Bar {
+    /// # Bar(Foo)
+    ///     }
     /// }
     /// ```
-    #[clippy::version = "1.51.0"]
-    pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-    pedantic,
-    "Checks for calls to ends_with with case-sensitive file extensions"
+    ///
+    /// ```no_run
+    /// # struct Foo;
+    /// # struct FooError;
+    /// impl Foo {
+    ///     // Good. Return type contains `Self`
+    ///     fn new() -> Result<Foo, FooError> {
+    /// # Ok(Foo)
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Or in a trait definition:
+    /// ```no_run
+    /// pub trait Trait {
+    ///     // Bad. The type name must contain `Self`
+    ///     fn new();
+    /// }
+    /// ```
+    ///
+    /// ```no_run
+    /// pub trait Trait {
+    ///     // Good. Return type contains `Self`
+    ///     fn new() -> Self;
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NEW_RET_NO_SELF,
+    style,
+    "not returning type containing `Self` in a `new` method"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `x.get(0)` instead of
-    /// `x.first()` or `x.front()`.
+    /// Checks for `replace` statements which have no effect.
     ///
     /// ### Why is this bad?
-    /// Using `x.first()` for `Vec`s and slices or `x.front()`
-    /// for `VecDeque`s is easier to read and has the same result.
+    /// It's either a mistake or confusing.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = vec![2, 3, 5];
-    /// let first_element = x.get(0);
+    /// "1234".replace("12", "12");
+    /// "1234".replacen("12", "12", 1);
     /// ```
+    #[clippy::version = "1.63.0"]
+    pub NO_EFFECT_REPLACE,
+    suspicious,
+    "replace with no effect"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for duplicate open options as well as combinations
+    /// that make no sense.
     ///
-    /// Use instead:
+    /// ### Why is this bad?
+    /// In the best case, the code will be harder to read than
+    /// necessary. I don't know the worst case.
+    ///
+    /// ### Example
     /// ```no_run
-    /// let x = vec![2, 3, 5];
-    /// let first_element = x.first();
+    /// use std::fs::OpenOptions;
+    ///
+    /// OpenOptions::new().read(true).truncate(true);
     /// ```
-    #[clippy::version = "1.63.0"]
-    pub GET_FIRST,
-    style,
-    "Using `x.get(0)` when `x.first()` or `x.front()` is simpler"
+    #[clippy::version = "pre 1.29.0"]
+    pub NONSENSICAL_OPEN_OPTIONS,
+    correctness,
+    "nonsensical combination of options for opening a file"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Finds patterns that reimplement `Option::ok_or`.
+    /// Checks for unnecessary method chains that can be simplified into `if .. else ..`.
     ///
     /// ### Why is this bad?
+    /// This can be written more clearly with `if .. else ..`
     ///
-    /// Concise code helps focusing on behavior instead of boilerplate.
+    /// ### Limitations
+    /// This lint currently only looks for usages of
+    /// `.{then, then_some}(..).{unwrap_or, unwrap_or_else, unwrap_or_default}(..)`, but will be expanded
+    /// to account for similar patterns.
     ///
-    /// ### Examples
+    /// ### Example
     /// ```no_run
-    /// let foo: Option<i32> = None;
-    /// foo.map_or(Err("error"), |v| Ok(v));
+    /// let x = true;
+    /// x.then_some("a").unwrap_or("b");
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// let foo: Option<i32> = None;
-    /// foo.ok_or("error");
+    /// let x = true;
+    /// if x { "a" } else { "b" };
     /// ```
-    #[clippy::version = "1.49.0"]
-    pub MANUAL_OK_OR,
+    #[clippy::version = "1.64.0"]
+    pub OBFUSCATED_IF_ELSE,
     style,
-    "finds patterns that can be encoded more concisely with `Option::ok_or`"
+    "use of `.then_some(..).unwrap_or(..)` can be written \
+    more clearly with `if .. else ..`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `map(|x| x.clone())` or
-    /// dereferencing closures for `Copy` types, on `Iterator` or `Option`,
-    /// and suggests `cloned()` or `copied()` instead
+    /// Checks for usage of `ok().expect(..)`.
+    ///
+    /// Note: This lint only triggers for code marked compatible
+    /// with versions of the compiler older than Rust 1.82.0.
     ///
     /// ### Why is this bad?
-    /// Readability, this can be written more concisely
+    /// Because you usually call `expect()` on the `Result`
+    /// directly to get a better error message.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = vec![42, 43];
-    /// let y = x.iter();
-    /// let z = y.map(|i| *i);
+    /// # let x = Ok::<_, ()>(());
+    /// x.ok().expect("why did I do this again?");
     /// ```
     ///
-    /// The correct use would be:
-    ///
+    /// Use instead:
     /// ```no_run
-    /// let x = vec![42, 43];
-    /// let y = x.iter();
-    /// let z = y.cloned();
+    /// # let x = Ok::<_, ()>(());
+    /// x.expect("why did I do this again?");
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub MAP_CLONE,
+    pub OK_EXPECT,
     style,
-    "using `iterator.map(|x| x.clone())`, or dereferencing closures for `Copy` types"
+    "using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for instances of `map_err(|_| Some::Enum)`
+    /// Checks for usage of `.as_ref().cloned()` and `.as_mut().cloned()` on `Option`s
     ///
-    /// ### Why restrict this?
-    /// This `map_err` throws away the original error rather than allowing the enum to
-    /// contain and report the cause of the error.
+    /// ### Why is this bad?
+    /// This can be written more concisely by cloning the `Option` directly.
     ///
     /// ### Example
-    /// Before:
     /// ```no_run
-    /// use std::fmt;
-    ///
-    /// #[derive(Debug)]
-    /// enum Error {
-    ///     Indivisible,
-    ///     Remainder(u8),
-    /// }
-    ///
-    /// impl fmt::Display for Error {
-    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    ///         match self {
-    ///             Error::Indivisible => write!(f, "could not divide input by three"),
-    ///             Error::Remainder(remainder) => write!(
-    ///                 f,
-    ///                 "input is not divisible by three, remainder = {}",
-    ///                 remainder
-    ///             ),
-    ///         }
-    ///     }
-    /// }
-    ///
-    /// impl std::error::Error for Error {}
-    ///
-    /// fn divisible_by_3(input: &str) -> Result<(), Error> {
-    ///     input
-    ///         .parse::<i32>()
-    ///         .map_err(|_| Error::Indivisible)
-    ///         .map(|v| v % 3)
-    ///         .and_then(|remainder| {
-    ///             if remainder == 0 {
-    ///                 Ok(())
-    ///             } else {
-    ///                 Err(Error::Remainder(remainder as u8))
-    ///             }
-    ///         })
+    /// fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> {
+    ///     bar.as_ref().cloned()
     /// }
     /// ```
-    ///
-    /// After:
-    /// ```rust
-    /// use std::{fmt, num::ParseIntError};
-    ///
-    /// #[derive(Debug)]
-    /// enum Error {
-    ///     Indivisible(ParseIntError),
-    ///     Remainder(u8),
-    /// }
-    ///
-    /// impl fmt::Display for Error {
-    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    ///         match self {
-    ///             Error::Indivisible(_) => write!(f, "could not divide input by three"),
-    ///             Error::Remainder(remainder) => write!(
-    ///                 f,
-    ///                 "input is not divisible by three, remainder = {}",
-    ///                 remainder
-    ///             ),
-    ///         }
-    ///     }
-    /// }
-    ///
-    /// impl std::error::Error for Error {
-    ///     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-    ///         match self {
-    ///             Error::Indivisible(source) => Some(source),
-    ///             _ => None,
-    ///         }
-    ///     }
-    /// }
-    ///
-    /// fn divisible_by_3(input: &str) -> Result<(), Error> {
-    ///     input
-    ///         .parse::<i32>()
-    ///         .map_err(Error::Indivisible)
-    ///         .map(|v| v % 3)
-    ///         .and_then(|remainder| {
-    ///             if remainder == 0 {
-    ///                 Ok(())
-    ///             } else {
-    ///                 Err(Error::Remainder(remainder as u8))
-    ///             }
-    ///         })
+    /// Use instead:
+    /// ```no_run
+    /// fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> {
+    ///     bar.clone()
     /// }
     /// ```
-    #[clippy::version = "1.48.0"]
-    pub MAP_ERR_IGNORE,
-    restriction,
-    "`map_err` should not ignore the original error"
+    #[clippy::version = "1.77.0"]
+    pub OPTION_AS_REF_CLONED,
+    pedantic,
+    "cloning an `Option` via `as_ref().cloned()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `&mut Mutex::lock` calls
+    /// Checks for usage of `_.as_ref().map(Deref::deref)` or its aliases (such as String::as_str).
     ///
     /// ### Why is this bad?
-    /// `Mutex::lock` is less efficient than
-    /// calling `Mutex::get_mut`. In addition you also have a statically
-    /// guarantee that the mutex isn't locked, instead of just a runtime
-    /// guarantee.
-    ///
+    /// Readability, this can be written more concisely as
+    /// `_.as_deref()`.
+    ///
     /// ### Example
     /// ```no_run
-    /// use std::sync::{Arc, Mutex};
+    /// # let opt = Some("".to_string());
+    /// opt.as_ref().map(String::as_str)
+    /// # ;
+    /// ```
+    /// Can be written as
+    /// ```no_run
+    /// # let opt = Some("".to_string());
+    /// opt.as_deref()
+    /// # ;
+    /// ```
+    #[clippy::version = "1.42.0"]
+    pub OPTION_AS_REF_DEREF,
+    complexity,
+    "using `as_ref().map(Deref::deref)`, which is more succinctly expressed as `as_deref()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for iterators of `Option`s using `.filter(Option::is_some).map(Option::unwrap)` that may
+    /// be replaced with a `.flatten()` call.
     ///
-    /// let mut value_rc = Arc::new(Mutex::new(42_u8));
-    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
+    /// ### Why is this bad?
+    /// `Option` is like a collection of 0-1 things, so `flatten`
+    /// automatically does this without suspicious-looking `unwrap` calls.
     ///
-    /// let mut value = value_mutex.lock().unwrap();
-    /// *value += 1;
+    /// ### Example
+    /// ```no_run
+    /// let _ = std::iter::empty::<Option<i32>>().filter(Option::is_some).map(Option::unwrap);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// use std::sync::{Arc, Mutex};
+    /// let _ = std::iter::empty::<Option<i32>>().flatten();
+    /// ```
+    #[clippy::version = "1.53.0"]
+    pub OPTION_FILTER_MAP,
+    complexity,
+    "filtering `Option` for `Some` then force-unwrapping, which can be one type-safe operation"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.map_or(None, _)`.
     ///
-    /// let mut value_rc = Arc::new(Mutex::new(42_u8));
-    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.and_then(_)`.
     ///
-    /// let value = value_mutex.get_mut().unwrap();
-    /// *value += 1;
+    /// ### Known problems
+    /// The order of the arguments is not in execution order.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let opt = Some(1);
+    /// opt.map_or(None, |a| Some(a + 1));
     /// ```
-    #[clippy::version = "1.49.0"]
-    pub MUT_MUTEX_LOCK,
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let opt = Some(1);
+    /// opt.and_then(|a| Some(a + 1));
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub OPTION_MAP_OR_NONE,
     style,
-    "`&mut Mutex::lock` does unnecessary locking"
+    "using `Option.map_or(None, f)`, which is more succinctly expressed as `and_then(f)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for duplicate open options as well as combinations
-    /// that make no sense.
+    /// Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
+    /// `.or_insert(foo(..))` etc., and suggests to use `.or_else(|| foo(..))`,
+    /// `.unwrap_or_else(|| foo(..))`, `.unwrap_or_default()` or `.or_default()`
+    /// etc. instead.
     ///
     /// ### Why is this bad?
-    /// In the best case, the code will be harder to read than
-    /// necessary. I don't know the worst case.
+    /// The function will always be called. This is only bad if it allocates or
+    /// does some non-trivial amount of work.
+    ///
+    /// ### Known problems
+    /// If the function has side-effects, not calling it will change the
+    /// semantic of the program, but you shouldn't rely on that.
+    ///
+    /// The lint also cannot figure out whether the function you call is
+    /// actually expensive to call or not.
     ///
     /// ### Example
     /// ```no_run
-    /// use std::fs::OpenOptions;
+    /// # let foo = Some(String::new());
+    /// foo.unwrap_or(String::from("empty"));
+    /// ```
     ///
-    /// OpenOptions::new().read(true).truncate(true);
+    /// Use instead:
+    /// ```no_run
+    /// # let foo = Some(String::new());
+    /// foo.unwrap_or_else(|| String::from("empty"));
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub NONSENSICAL_OPEN_OPTIONS,
-    correctness,
-    "nonsensical combination of options for opening a file"
+    pub OR_FUN_CALL,
+    nursery,
+    "using any `*or` method with a function call, which suggests `*or_else`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the suspicious use of `OpenOptions::create()`
-    /// without an explicit `OpenOptions::truncate()`.
+    /// Checks for `.or(…).unwrap()` calls to Options and Results.
     ///
     /// ### Why is this bad?
-    /// `create()` alone will either create a new file or open an
-    /// existing file. If the file already exists, it will be
-    /// overwritten when written to, but the file will not be
-    /// truncated by default.
-    /// If less data is written to the file
-    /// than it already contains, the remainder of the file will
-    /// remain unchanged, and the end of the file will contain old
-    /// data.
-    /// In most cases, one should either use `create_new` to ensure
-    /// the file is created from scratch, or ensure `truncate` is
-    /// called so that the truncation behaviour is explicit. `truncate(true)`
-    /// will ensure the file is entirely overwritten with new data, whereas
-    /// `truncate(false)` will explicitly keep the default behavior.
+    /// You should use `.unwrap_or(…)` instead for clarity.
     ///
     /// ### Example
-    /// ```rust,no_run
-    /// use std::fs::OpenOptions;
+    /// ```no_run
+    /// # let fallback = "fallback";
+    /// // Result
+    /// # type Error = &'static str;
+    /// # let result: Result<&str, Error> = Err("error");
+    /// let value = result.or::<Error>(Ok(fallback)).unwrap();
     ///
-    /// OpenOptions::new().create(true);
+    /// // Option
+    /// # let option: Option<&str> = None;
+    /// let value = option.or(Some(fallback)).unwrap();
     /// ```
     /// Use instead:
-    /// ```rust,no_run
-    /// use std::fs::OpenOptions;
+    /// ```no_run
+    /// # let fallback = "fallback";
+    /// // Result
+    /// # let result: Result<&str, &str> = Err("error");
+    /// let value = result.unwrap_or(fallback);
     ///
-    /// OpenOptions::new().create(true).truncate(true);
+    /// // Option
+    /// # let option: Option<&str> = None;
+    /// let value = option.unwrap_or(fallback);
     /// ```
-    #[clippy::version = "1.77.0"]
-    pub SUSPICIOUS_OPEN_OPTIONS,
-    suspicious,
-    "suspicious combination of options for opening a file"
+    #[clippy::version = "1.61.0"]
+    pub OR_THEN_UNWRAP,
+    complexity,
+    "checks for `.or(…).unwrap()` calls to Options and Results."
 }
 
 declare_clippy_lint! {
@@ -2981,306 +2965,416 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for zipping a collection with the range of
-    /// `0.._.len()`.
+    /// Looks for calls to `Path::ends_with` calls where the argument looks like a file extension.
+    ///
+    /// By default, Clippy has a short list of known filenames that start with a dot
+    /// but aren't necessarily file extensions (e.g. the `.git` folder), which are allowed by default.
+    /// The `allowed-dotfiles` configuration can be used to allow additional
+    /// file extensions that Clippy should not lint.
     ///
     /// ### Why is this bad?
-    /// The code is better expressed with `.enumerate()`.
+    /// This doesn't actually compare file extensions. Rather, `ends_with` compares the given argument
+    /// to the last **component** of the path and checks if it matches exactly.
+    ///
+    /// ### Known issues
+    /// File extensions are often at most three characters long, so this only lints in those cases
+    /// in an attempt to avoid false positives.
+    /// Any extension names longer than that are assumed to likely be real path components and are
+    /// therefore ignored.
     ///
     /// ### Example
     /// ```no_run
-    /// # let x = vec![1];
-    /// let _ = x.iter().zip(0..x.len());
+    /// # use std::path::Path;
+    /// fn is_markdown(path: &Path) -> bool {
+    ///     path.ends_with(".md")
+    /// }
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # let x = vec![1];
-    /// let _ = x.iter().enumerate();
+    /// # use std::path::Path;
+    /// fn is_markdown(path: &Path) -> bool {
+    ///     path.extension().is_some_and(|ext| ext == "md")
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub RANGE_ZIP_WITH_LEN,
-    complexity,
-    "zipping iterator with a range when `enumerate()` would do"
+    #[clippy::version = "1.74.0"]
+    pub PATH_ENDS_WITH_EXT,
+    suspicious,
+    "attempting to compare file extensions using `Path::ends_with`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.repeat(1)` and suggest the following method for each types.
-    /// - `.to_string()` for `str`
-    /// - `.clone()` for `String`
-    /// - `.to_vec()` for `slice`
-    ///
-    /// The lint will evaluate constant expressions and values as arguments of `.repeat(..)` and emit a message if
-    /// they are equivalent to `1`. (Related discussion in [rust-clippy#7306](https://github.com/rust-lang/rust-clippy/issues/7306))
+    /// Checks for usage of the `offset` pointer method with an integer
+    /// literal.
     ///
     /// ### Why is this bad?
-    /// For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning
-    /// the string is the intention behind this, `clone()` should be used.
+    /// The `add` and `sub` methods more accurately express the intent.
     ///
     /// ### Example
     /// ```no_run
-    /// fn main() {
-    ///     let x = String::from("hello world").repeat(1);
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    ///
+    /// unsafe {
+    ///     ptr.offset(-8);
     /// }
     /// ```
-    /// Use instead:
+    ///
+    /// Could be written:
+    ///
     /// ```no_run
-    /// fn main() {
-    ///     let x = String::from("hello world").clone();
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    ///
+    /// unsafe {
+    ///     ptr.sub(8);
     /// }
     /// ```
-    #[clippy::version = "1.47.0"]
-    pub REPEAT_ONCE,
-    complexity,
-    "using `.repeat(1)` instead of `String.clone()`, `str.to_string()` or `slice.to_vec()` "
+    #[clippy::version = "1.92.0"]
+    pub PTR_OFFSET_BY_LITERAL,
+    pedantic,
+    "unneeded pointer offset"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// When sorting primitive values (integers, bools, chars, as well
-    /// as arrays, slices, and tuples of such items), it is typically better to
-    /// use an unstable sort than a stable sort.
+    /// Checks for usage of the `offset` pointer method with a `usize` casted to an
+    /// `isize`.
     ///
     /// ### Why is this bad?
-    /// Typically, using a stable sort consumes more memory and cpu cycles.
-    /// Because values which compare equal are identical, preserving their
-    /// relative order (the guarantee that a stable sort provides) means
-    /// nothing, while the extra costs still apply.
+    /// If we’re always increasing the pointer address, we can avoid the numeric
+    /// cast by using the `add` method instead.
     ///
-    /// ### Known problems
+    /// ### Example
+    /// ```no_run
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    /// let offset = 1_usize;
     ///
-    /// As pointed out in
-    /// [issue #8241](https://github.com/rust-lang/rust-clippy/issues/8241),
-    /// a stable sort can instead be significantly faster for certain scenarios
-    /// (eg. when a sorted vector is extended with new data and resorted).
+    /// unsafe {
+    ///     ptr.offset(offset as isize);
+    /// }
+    /// ```
     ///
-    /// For more information and benchmarking results, please refer to the
-    /// issue linked above.
+    /// Could be written:
+    ///
+    /// ```no_run
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    /// let offset = 1_usize;
+    ///
+    /// unsafe {
+    ///     ptr.add(offset);
+    /// }
+    /// ```
+    #[clippy::version = "1.30.0"]
+    pub PTR_OFFSET_WITH_CAST,
+    complexity,
+    "unneeded pointer offset cast"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for zipping a collection with the range of
+    /// `0.._.len()`.
+    ///
+    /// ### Why is this bad?
+    /// The code is better expressed with `.enumerate()`.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut vec = vec![2, 1, 3];
-    /// vec.sort();
+    /// # let x = vec![1];
+    /// let _ = x.iter().zip(0..x.len());
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let mut vec = vec![2, 1, 3];
-    /// vec.sort_unstable();
+    /// # let x = vec![1];
+    /// let _ = x.iter().enumerate();
     /// ```
-    #[clippy::version = "1.47.0"]
-    pub STABLE_SORT_PRIMITIVE,
-    pedantic,
-    "use of sort() when sort_unstable() is equivalent"
+    #[clippy::version = "pre 1.29.0"]
+    pub RANGE_ZIP_WITH_LEN,
+    complexity,
+    "zipping iterator with a range when `enumerate()` would do"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Looks for calls to `.type_id()` on a `Box<dyn _>`.
+    /// Looks for calls to [`Stdin::read_line`] to read a line from the standard input
+    /// into a string, then later attempting to use that string for an operation that will never
+    /// work for strings with a trailing newline character in it (e.g. parsing into a `i32`).
     ///
     /// ### Why is this bad?
-    /// This almost certainly does not do what the user expects and can lead to subtle bugs.
-    /// Calling `.type_id()` on a `Box<dyn Trait>` returns a fixed `TypeId` of the `Box` itself,
-    /// rather than returning the `TypeId` of the underlying type behind the trait object.
-    ///
-    /// For `Box<dyn Any>` specifically (and trait objects that have `Any` as its supertrait),
-    /// this lint will provide a suggestion, which is to dereference the receiver explicitly
-    /// to go from `Box<dyn Any>` to `dyn Any`.
-    /// This makes sure that `.type_id()` resolves to a dynamic call on the trait object
-    /// and not on the box.
-    ///
-    /// If the fixed `TypeId` of the `Box` is the intended behavior, it's better to be explicit about it
-    /// and write `TypeId::of::<Box<dyn Trait>>()`:
-    /// this makes it clear that a fixed `TypeId` is returned and not the `TypeId` of the implementor.
+    /// The operation will always fail at runtime no matter what the user enters, thus
+    /// making it a useless operation.
     ///
     /// ### Example
     /// ```rust,ignore
-    /// use std::any::{Any, TypeId};
-    ///
-    /// let any_box: Box<dyn Any> = Box::new(42_i32);
-    /// assert_eq!(any_box.type_id(), TypeId::of::<i32>()); // ⚠️ this fails!
+    /// let mut input = String::new();
+    /// std::io::stdin().read_line(&mut input).expect("Failed to read a line");
+    /// let num: i32 = input.parse().expect("Not a number!");
+    /// assert_eq!(num, 42); // we never even get here!
     /// ```
     /// Use instead:
-    /// ```no_run
-    /// use std::any::{Any, TypeId};
-    ///
-    /// let any_box: Box<dyn Any> = Box::new(42_i32);
-    /// assert_eq!((*any_box).type_id(), TypeId::of::<i32>());
-    /// //          ^ dereference first, to call `type_id` on `dyn Any`
+    /// ```rust,ignore
+    /// let mut input = String::new();
+    /// std::io::stdin().read_line(&mut input).expect("Failed to read a line");
+    /// let num: i32 = input.trim_end().parse().expect("Not a number!");
+    /// //                  ^^^^^^^^^^^ remove the trailing newline
+    /// assert_eq!(num, 42);
     /// ```
     #[clippy::version = "1.73.0"]
-    pub TYPE_ID_ON_BOX,
-    suspicious,
-    "calling `.type_id()` on a boxed trait object"
+    pub READ_LINE_WITHOUT_TRIM,
+    correctness,
+    "calling `Stdin::read_line`, then trying to parse it without first trimming"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detects `().hash(_)`.
+    /// Looks for calls to `RwLock::write` where the lock is only used for reading.
     ///
     /// ### Why is this bad?
-    /// Hashing a unit value doesn't do anything as the implementation of `Hash` for `()` is a no-op.
+    /// The write portion of `RwLock` is exclusive, meaning that no other thread
+    /// can access the lock while this writer is active.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::hash::Hash;
-    /// # use std::collections::hash_map::DefaultHasher;
-    /// # enum Foo { Empty, WithValue(u8) }
-    /// # use Foo::*;
-    /// # let mut state = DefaultHasher::new();
-    /// # let my_enum = Foo::Empty;
-    /// match my_enum {
-    /// 	Empty => ().hash(&mut state),
-    /// 	WithValue(x) => x.hash(&mut state),
+    /// use std::sync::RwLock;
+    /// fn assert_is_zero(lock: &RwLock<i32>) {
+    ///     let num = lock.write().unwrap();
+    ///     assert_eq!(*num, 0);
     /// }
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// # use std::hash::Hash;
-    /// # use std::collections::hash_map::DefaultHasher;
-    /// # enum Foo { Empty, WithValue(u8) }
-    /// # use Foo::*;
-    /// # let mut state = DefaultHasher::new();
-    /// # let my_enum = Foo::Empty;
-    /// match my_enum {
-    /// 	Empty => 0_u8.hash(&mut state),
-    /// 	WithValue(x) => x.hash(&mut state),
+    /// use std::sync::RwLock;
+    /// fn assert_is_zero(lock: &RwLock<i32>) {
+    ///     let num = lock.read().unwrap();
+    ///     assert_eq!(*num, 0);
     /// }
     /// ```
-    #[clippy::version = "1.58.0"]
-    pub UNIT_HASH,
-    correctness,
-    "hashing a unit value, which does nothing"
+    #[clippy::version = "1.73.0"]
+    pub READONLY_WRITE_LOCK,
+    perf,
+    "acquiring a write lock when a read lock would work"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `Vec::sort_by` passing in a closure
-    /// which compares the two arguments, either directly or indirectly.
+    /// Checks for usage of `as_str()` on a `String` chained with a method available on the `String` itself.
     ///
     /// ### Why is this bad?
-    /// It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if
-    /// possible) than to use `Vec::sort_by` and a more complicated
-    /// closure.
-    ///
-    /// ### Known problems
-    /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't already
-    /// imported by a use statement, then it will need to be added manually.
+    /// The `as_str()` conversion is pointless and can be removed for simplicity and cleanliness.
     ///
     /// ### Example
     /// ```no_run
-    /// # struct A;
-    /// # impl A { fn foo(&self) {} }
-    /// # let mut vec: Vec<A> = Vec::new();
-    /// vec.sort_by(|a, b| a.foo().cmp(&b.foo()));
+    /// let owned_string = "This is a string".to_owned();
+    /// owned_string.as_str().as_bytes()
+    /// # ;
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// # struct A;
-    /// # impl A { fn foo(&self) {} }
-    /// # let mut vec: Vec<A> = Vec::new();
-    /// vec.sort_by_key(|a| a.foo());
+    /// let owned_string = "This is a string".to_owned();
+    /// owned_string.as_bytes()
+    /// # ;
     /// ```
-    #[clippy::version = "1.46.0"]
-    pub UNNECESSARY_SORT_BY,
+    #[clippy::version = "1.74.0"]
+    pub REDUNDANT_AS_STR,
     complexity,
-    "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer"
+    "`as_str` used to call a method on `str` that is also available on `String`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds occurrences of `Vec::resize(0, an_int)`
+    /// Checks for calls to `Iterator::cloned` where the original value could be used
+    /// instead.
     ///
     /// ### Why is this bad?
-    /// This is probably an argument inversion mistake.
+    /// It is not always possible for the compiler to eliminate useless allocations and
+    /// deallocations generated by redundant `clone()`s.
     ///
     /// ### Example
     /// ```no_run
-    /// vec![1, 2, 3, 4, 5].resize(0, 5)
+    /// let x = vec![String::new()];
+    /// let _ = x.iter().cloned().map(|x| x.len());
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// vec![1, 2, 3, 4, 5].clear()
+    /// let x = vec![String::new()];
+    /// let _ = x.iter().map(|x| x.len());
     /// ```
-    #[clippy::version = "1.46.0"]
-    pub VEC_RESIZE_TO_ZERO,
-    correctness,
-    "emptying a vector with `resize(0, an_int)` instead of `clear()` is probably an argument inversion mistake"
+    #[clippy::version = "1.92.0"]
+    pub REDUNDANT_ITER_CLONED,
+    perf,
+    "detects redundant calls to `Iterator::cloned`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of File::read_to_end and File::read_to_string.
+    /// Checks for usage of `.repeat(1)` and suggest the following method for each types.
+    /// - `.to_string()` for `str`
+    /// - `.clone()` for `String`
+    /// - `.to_vec()` for `slice`
     ///
-    /// ### Why restrict this?
-    /// `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.
-    /// See also: [fs::read docs](https://doc.rust-lang.org/std/fs/fn.read.html), [fs::read_to_string docs](https://doc.rust-lang.org/std/fs/fn.read_to_string.html)
+    /// The lint will evaluate constant expressions and values as arguments of `.repeat(..)` and emit a message if
+    /// they are equivalent to `1`. (Related discussion in [rust-clippy#7306](https://github.com/rust-lang/rust-clippy/issues/7306))
+    ///
+    /// ### Why is this bad?
+    /// For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning
+    /// the string is the intention behind this, `clone()` should be used.
     ///
     /// ### Example
-    /// ```rust,no_run
-    /// # use std::io::Read;
-    /// # use std::fs::File;
-    /// let mut f = File::open("foo.txt").unwrap();
-    /// let mut bytes = Vec::new();
-    /// f.read_to_end(&mut bytes).unwrap();
+    /// ```no_run
+    /// fn main() {
+    ///     let x = String::from("hello world").repeat(1);
+    /// }
     /// ```
-    /// Can be written more concisely as
-    /// ```rust,no_run
-    /// # use std::fs;
-    /// let mut bytes = fs::read("foo.txt").unwrap();
+    /// Use instead:
+    /// ```no_run
+    /// fn main() {
+    ///     let x = String::from("hello world").clone();
+    /// }
     /// ```
-    #[clippy::version = "1.44.0"]
-    pub VERBOSE_FILE_READS,
-    restriction,
-    "use of `File::read_to_end` or `File::read_to_string`"
+    #[clippy::version = "1.47.0"]
+    pub REPEAT_ONCE,
+    complexity,
+    "using `.repeat(1)` instead of `String.clone()`, `str.to_string()` or `slice.to_vec()` "
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Checks for iterating a map (`HashMap` or `BTreeMap`) and
-    /// ignoring either the keys or values.
+    /// Checks for iterators of `Result`s using `.filter(Result::is_ok).map(Result::unwrap)` that may
+    /// be replaced with a `.flatten()` call.
     ///
     /// ### Why is this bad?
-    ///
-    /// Readability. There are `keys` and `values` methods that
-    /// can be used to express that we only need the keys or the values.
+    /// `Result` implements `IntoIterator<Item = T>`. This means that `Result` can be flattened
+    /// automatically without suspicious-looking `unwrap` calls.
     ///
     /// ### Example
-    ///
     /// ```no_run
-    /// # use std::collections::HashMap;
-    /// let map: HashMap<u32, u32> = HashMap::new();
-    /// let values = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+    /// let _ = std::iter::empty::<Result<i32, ()>>().filter(Result::is_ok).map(Result::unwrap);
     /// ```
-    ///
     /// Use instead:
     /// ```no_run
-    /// # use std::collections::HashMap;
-    /// let map: HashMap<u32, u32> = HashMap::new();
-    /// let values = map.values().collect::<Vec<_>>();
+    /// let _ = std::iter::empty::<Result<i32, ()>>().flatten();
     /// ```
-    #[clippy::version = "1.66.0"]
-    pub ITER_KV_MAP,
+    #[clippy::version = "1.77.0"]
+    pub RESULT_FILTER_MAP,
     complexity,
-    "iterating on map using `iter` when `keys` or `values` would do"
+    "filtering `Result` for `Ok` then force-unwrapping, which can be one type-safe operation"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Checks if the `seek` method of the `Seek` trait is called with `SeekFrom::Current(0)`,
-    /// and if it is, suggests using `stream_position` instead.
+    /// Checks for usage of `_.map_or(None, Some)`.
     ///
     /// ### Why is this bad?
-    ///
-    /// Readability. Use dedicated method.
+    /// Readability, this can be written more concisely as
+    /// `_.ok()`.
     ///
     /// ### Example
-    ///
-    /// ```rust,no_run
-    /// use std::fs::File;
+    /// ```no_run
+    /// # let r: Result<u32, &str> = Ok(1);
+    /// assert_eq!(Some(1), r.map_or(None, Some));
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let r: Result<u32, &str> = Ok(1);
+    /// assert_eq!(Some(1), r.ok());
+    /// ```
+    #[clippy::version = "1.44.0"]
+    pub RESULT_MAP_OR_INTO_OPTION,
+    style,
+    "using `Result.map_or(None, Some)`, which is more succinctly expressed as `ok()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detect functions that end with `Option::and_then` or `Result::and_then`, and suggest using
+    /// the `?` operator instead.
+    ///
+    /// ### Why is this bad?
+    /// The `and_then` method is used to chain a computation that returns an `Option` or a `Result`.
+    /// This can be replaced with the `?` operator, which is more concise and idiomatic.
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// fn test(opt: Option<i32>) -> Option<i32> {
+    ///     opt.and_then(|n| {
+    ///         if n > 1 {
+    ///             Some(n + 1)
+    ///         } else {
+    ///             None
+    ///        }
+    ///     })
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn test(opt: Option<i32>) -> Option<i32> {
+    ///     let n = opt?;
+    ///     if n > 1 {
+    ///         Some(n + 1)
+    ///     } else {
+    ///         None
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub RETURN_AND_THEN,
+    restriction,
+    "using `Option::and_then` or `Result::and_then` to chain a computation that returns an `Option` or a `Result`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for an iterator or string search (such as `find()`,
+    /// `position()`, or `rposition()`) followed by a call to `is_some()` or `is_none()`.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as:
+    /// * `_.any(_)`, or `_.contains(_)` for `is_some()`,
+    /// * `!_.any(_)`, or `!_.contains(_)` for `is_none()`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vec = vec![1];
+    /// vec.iter().find(|x| **x == 0).is_some();
+    ///
+    /// "hello world".find("world").is_none();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let vec = vec![1];
+    /// vec.iter().any(|x| *x == 0);
+    ///
+    /// !"hello world".contains("world");
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub SEARCH_IS_SOME,
+    nursery,
+    "using an iterator or string search followed by `is_some()` or `is_none()`, which is more succinctly expressed as a call to `any()` or `contains()` (with negation in case of `is_none()`)"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks if the `seek` method of the `Seek` trait is called with `SeekFrom::Current(0)`,
+    /// and if it is, suggests using `stream_position` instead.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Readability. Use dedicated method.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,no_run
+    /// use std::fs::File;
     /// use std::io::{self, Write, Seek, SeekFrom};
     ///
     /// fn main() -> io::Result<()> {
@@ -3343,197 +3437,209 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for functions collecting an iterator when collect
-    /// is not needed.
+    /// Checks for methods that should live in a trait
+    /// implementation of a `std` trait (see [llogiq's blog
+    /// post](http://llogiq.github.io/2015/07/30/traits.html) for further
+    /// information) instead of an inherent implementation.
     ///
     /// ### Why is this bad?
-    /// `collect` causes the allocation of a new data structure,
-    /// when this allocation may not be needed.
+    /// Implementing the traits improve ergonomics for users of
+    /// the code, often with very little cost. Also people seeing a `mul(...)`
+    /// method
+    /// may expect `*` to work equally, so you should have good reason to disappoint
+    /// them.
     ///
     /// ### Example
     /// ```no_run
-    /// # let iterator = vec![1].into_iter();
-    /// let len = iterator.collect::<Vec<_>>().len();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let iterator = vec![1].into_iter();
-    /// let len = iterator.count();
+    /// struct X;
+    /// impl X {
+    ///     fn add(&self, other: &X) -> X {
+    ///         // ..
+    /// # X
+    ///     }
+    /// }
     /// ```
-    #[clippy::version = "1.30.0"]
-    pub NEEDLESS_COLLECT,
-    nursery,
-    "collecting an iterator when collect is not needed"
+    #[clippy::version = "pre 1.29.0"]
+    pub SHOULD_IMPLEMENT_TRAIT,
+    style,
+    "defining a method that should be implementing a std trait"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Checks for `Command::arg()` invocations that look like they
-    /// should be multiple arguments instead, such as `arg("-t ext2")`.
+    /// Warns when using `push_str`/`insert_str` with a single-character string literal
+    /// where `push`/`insert` with a `char` would work fine.
     ///
     /// ### Why is this bad?
-    ///
-    /// `Command::arg()` does not split arguments by space. An argument like `arg("-t ext2")`
-    /// will be passed as a single argument to the command,
-    /// which is likely not what was intended.
+    /// It's less clear that we are pushing a single character.
     ///
     /// ### Example
     /// ```no_run
-    /// std::process::Command::new("echo").arg("-n hello").spawn().unwrap();
+    /// # let mut string = String::new();
+    /// string.insert_str(0, "R");
+    /// string.push_str("R");
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// std::process::Command::new("echo").args(["-n", "hello"]).spawn().unwrap();
+    /// # let mut string = String::new();
+    /// string.insert(0, 'R');
+    /// string.push('R');
     /// ```
-    #[clippy::version = "1.69.0"]
-    pub SUSPICIOUS_COMMAND_ARG_SPACE,
-    suspicious,
-    "single command line argument that looks like it should be multiple arguments"
+    #[clippy::version = "1.49.0"]
+    pub SINGLE_CHAR_ADD_STR,
+    style,
+    "`push_str()` or `insert_str()` used with a single-character string literal as parameter"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.drain(..)` for the sole purpose of clearing a container.
+    /// Checks for usage of `_.skip_while(condition).next()`.
     ///
     /// ### Why is this bad?
-    /// This creates an unnecessary iterator that is dropped immediately.
-    ///
-    /// Calling `.clear()` also makes the intent clearer.
+    /// Readability, this can be written more concisely as
+    /// `_.find(!condition)`.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut v = vec![1, 2, 3];
-    /// v.drain(..);
+    /// # let vec = vec![1];
+    /// vec.iter().skip_while(|x| **x == 0).next();
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let mut v = vec![1, 2, 3];
-    /// v.clear();
+    /// # let vec = vec![1];
+    /// vec.iter().find(|x| **x != 0);
     /// ```
-    #[clippy::version = "1.70.0"]
-    pub CLEAR_WITH_DRAIN,
-    nursery,
-    "calling `drain` in order to `clear` a container"
+    #[clippy::version = "1.42.0"]
+    pub SKIP_WHILE_NEXT,
+    complexity,
+    "using `skip_while(p).next()`, which is more succinctly expressed as `.find(!p)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `.rev().next()` on a `DoubleEndedIterator`
+    /// Checks for string slices immediately followed by `as_bytes`.
     ///
     /// ### Why is this bad?
-    /// `.next_back()` is cleaner.
+    /// It involves doing an unnecessary UTF-8 alignment check which is less efficient, and can cause a panic.
+    ///
+    /// ### Known problems
+    /// In some cases, the UTF-8 validation and potential panic from string slicing may be required for
+    /// the code's correctness. If you need to ensure the slice boundaries fall on valid UTF-8 character
+    /// boundaries, the original form (`s[1..5].as_bytes()`) should be preferred.
     ///
     /// ### Example
-    /// ```no_run
-    /// # let foo = [0; 10];
-    /// foo.iter().rev().next();
+    /// ```rust
+    /// let s = "Lorem ipsum";
+    /// s[1..5].as_bytes();
     /// ```
     /// Use instead:
-    /// ```no_run
-    /// # let foo = [0; 10];
-    /// foo.iter().next_back();
+    /// ```rust
+    /// let s = "Lorem ipsum";
+    /// &s.as_bytes()[1..5];
     /// ```
-    #[clippy::version = "1.71.0"]
-    pub MANUAL_NEXT_BACK,
-    style,
-    "manual reverse iteration of `DoubleEndedIterator`"
+     #[clippy::version = "1.86.0"]
+     pub SLICED_STRING_AS_BYTES,
+     perf,
+     "slicing a string and immediately calling as_bytes is less efficient and can lead to panics"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `.drain()` that clear the collection, immediately followed by a call to `.collect()`.
-    ///
-    /// > "Collection" in this context refers to any type with a `drain` method:
-    /// > `Vec`, `VecDeque`, `BinaryHeap`, `HashSet`,`HashMap`, `String`
+    /// When sorting primitive values (integers, bools, chars, as well
+    /// as arrays, slices, and tuples of such items), it is typically better to
+    /// use an unstable sort than a stable sort.
     ///
     /// ### Why is this bad?
-    /// Using `mem::take` is faster as it avoids the allocation.
-    /// When using `mem::take`, the old collection is replaced with an empty one and ownership of
-    /// the old collection is returned.
+    /// Typically, using a stable sort consumes more memory and cpu cycles.
+    /// Because values which compare equal are identical, preserving their
+    /// relative order (the guarantee that a stable sort provides) means
+    /// nothing, while the extra costs still apply.
     ///
-    /// ### Known issues
-    /// `mem::take(&mut vec)` is almost equivalent to `vec.drain(..).collect()`, except that
-    /// it also moves the **capacity**. The user might have explicitly written it this way
-    /// to keep the capacity on the original `Vec`.
+    /// ### Known problems
+    ///
+    /// As pointed out in
+    /// [issue #8241](https://github.com/rust-lang/rust-clippy/issues/8241),
+    /// a stable sort can instead be significantly faster for certain scenarios
+    /// (eg. when a sorted vector is extended with new data and resorted).
+    ///
+    /// For more information and benchmarking results, please refer to the
+    /// issue linked above.
     ///
     /// ### Example
     /// ```no_run
-    /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
-    ///     v.drain(..).collect()
-    /// }
+    /// let mut vec = vec![2, 1, 3];
+    /// vec.sort();
     /// ```
     /// Use instead:
     /// ```no_run
-    /// use std::mem;
-    /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
-    ///     mem::take(v)
-    /// }
+    /// let mut vec = vec![2, 1, 3];
+    /// vec.sort_unstable();
     /// ```
-    #[clippy::version = "1.72.0"]
-    pub DRAIN_COLLECT,
-    perf,
-    "calling `.drain(..).collect()` to move all elements into a new collection"
+    #[clippy::version = "1.47.0"]
+    pub STABLE_SORT_PRIMITIVE,
+    pedantic,
+    "use of sort() when sort_unstable() is equivalent"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `Iterator::fold` with a type that implements `Try`.
+    ///
+    /// Checks for usages of `str.trim().split("\n")` and `str.trim().split("\r\n")`.
     ///
     /// ### Why is this bad?
-    /// The code should use `try_fold` instead, which short-circuits on failure, thus opening the
-    /// door for additional optimizations not possible with `fold` as rustc can guarantee the
-    /// function is never called on `None`, `Err`, etc., alleviating otherwise necessary checks. It's
-    /// also slightly more idiomatic.
     ///
-    /// ### Known issues
-    /// This lint doesn't take into account whether a function does something on the failure case,
-    /// i.e., whether short-circuiting will affect behavior. Refactoring to `try_fold` is not
-    /// desirable in those cases.
+    /// Hard-coding the line endings makes the code less compatible. `str.lines` should be used instead.
     ///
     /// ### Example
     /// ```no_run
-    /// vec![1, 2, 3].iter().fold(Some(0i32), |sum, i| sum?.checked_add(*i));
+    /// "some\ntext\nwith\nnewlines\n".trim().split('\n');
     /// ```
     /// Use instead:
     /// ```no_run
-    /// vec![1, 2, 3].iter().try_fold(0i32, |sum, i| sum.checked_add(*i));
+    /// "some\ntext\nwith\nnewlines\n".lines();
     /// ```
-    #[clippy::version = "1.72.0"]
-    pub MANUAL_TRY_FOLD,
-    perf,
-    "checks for usage of `Iterator::fold` with a type that implements `Try`"
+    ///
+    /// ### Known Problems
+    ///
+    /// This lint cannot detect if the split is intentionally restricted to a single type of newline (`"\n"` or
+    /// `"\r\n"`), for example during the parsing of a specific file format in which precisely one newline type is
+    /// valid.
+    #[clippy::version = "1.77.0"]
+    pub STR_SPLIT_AT_NEWLINE,
+    pedantic,
+    "splitting a trimmed string at hard-coded newlines"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Looks for calls to [`Stdin::read_line`] to read a line from the standard input
-    /// into a string, then later attempting to use that string for an operation that will never
-    /// work for strings with a trailing newline character in it (e.g. parsing into a `i32`).
+    /// Checks for the use of `.extend(s.chars())` where s is a
+    /// `&str` or `String`.
     ///
     /// ### Why is this bad?
-    /// The operation will always fail at runtime no matter what the user enters, thus
-    /// making it a useless operation.
+    /// `.push_str(s)` is clearer
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// let mut input = String::new();
-    /// std::io::stdin().read_line(&mut input).expect("Failed to read a line");
-    /// let num: i32 = input.parse().expect("Not a number!");
-    /// assert_eq!(num, 42); // we never even get here!
+    /// ```no_run
+    /// let abc = "abc";
+    /// let def = String::from("def");
+    /// let mut s = String::new();
+    /// s.extend(abc.chars());
+    /// s.extend(def.chars());
     /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// let mut input = String::new();
-    /// std::io::stdin().read_line(&mut input).expect("Failed to read a line");
-    /// let num: i32 = input.trim_end().parse().expect("Not a number!");
-    /// //                  ^^^^^^^^^^^ remove the trailing newline
-    /// assert_eq!(num, 42);
+    /// The correct use would be:
+    /// ```no_run
+    /// let abc = "abc";
+    /// let def = String::from("def");
+    /// let mut s = String::new();
+    /// s.push_str(abc);
+    /// s.push_str(&def);
     /// ```
-    #[clippy::version = "1.73.0"]
-    pub READ_LINE_WITHOUT_TRIM,
-    correctness,
-    "calling `Stdin::read_line`, then trying to parse it without first trimming"
+    #[clippy::version = "pre 1.29.0"]
+    pub STRING_EXTEND_CHARS,
+    style,
+    "using `x.extend(s.chars())` where s is a `&str` or `String`"
 }
 
 declare_clippy_lint! {
@@ -3566,231 +3672,353 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.map(|_| format!(..)).collect::<String>()`.
+    ///
+    /// Checks for `Command::arg()` invocations that look like they
+    /// should be multiple arguments instead, such as `arg("-t ext2")`.
     ///
     /// ### Why is this bad?
-    /// This allocates a new string for every element in the iterator.
-    /// This can be done more efficiently by creating the `String` once and appending to it in `Iterator::fold`,
-    /// using either the `write!` macro which supports exactly the same syntax as the `format!` macro,
-    /// or concatenating with `+` in case the iterator yields `&str`/`String`.
     ///
-    /// Note also that `write!`-ing into a `String` can never fail, despite the return type of `write!` being `std::fmt::Result`,
-    /// so it can be safely ignored or unwrapped.
+    /// `Command::arg()` does not split arguments by space. An argument like `arg("-t ext2")`
+    /// will be passed as a single argument to the command,
+    /// which is likely not what was intended.
     ///
     /// ### Example
     /// ```no_run
-    /// fn hex_encode(bytes: &[u8]) -> String {
-    ///     bytes.iter().map(|b| format!("{b:02X}")).collect()
-    /// }
+    /// std::process::Command::new("echo").arg("-n hello").spawn().unwrap();
     /// ```
     /// Use instead:
     /// ```no_run
-    /// use std::fmt::Write;
-    /// fn hex_encode(bytes: &[u8]) -> String {
-    ///     bytes.iter().fold(String::new(), |mut output, b| {
-    ///         let _ = write!(output, "{b:02X}");
-    ///         output
-    ///     })
-    /// }
+    /// std::process::Command::new("echo").args(["-n", "hello"]).spawn().unwrap();
     /// ```
-    #[clippy::version = "1.73.0"]
-    pub FORMAT_COLLECT,
-    pedantic,
-    "`format!`ing every element in a collection, then collecting the strings into a new `String`"
+    #[clippy::version = "1.69.0"]
+    pub SUSPICIOUS_COMMAND_ARG_SPACE,
+    suspicious,
+    "single command line argument that looks like it should be multiple arguments"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.skip(0)` on iterators.
+    /// Checks for calls to `map` followed by a `count`.
     ///
     /// ### Why is this bad?
-    /// This was likely intended to be `.skip(1)` to skip the first element, as `.skip(0)` does
-    /// nothing. If not, the call should be removed.
+    /// It looks suspicious. Maybe `map` was confused with `filter`.
+    /// If the `map` call is intentional, this should be rewritten
+    /// using `inspect`. Or, if you intend to drive the iterator to
+    /// completion, you can just use `for_each` instead.
     ///
     /// ### Example
     /// ```no_run
-    /// let v = vec![1, 2, 3];
-    /// let x = v.iter().skip(0).collect::<Vec<_>>();
-    /// let y = v.iter().collect::<Vec<_>>();
-    /// assert_eq!(x, y);
+    /// let _ = (0..3).map(|x| x + 2).count();
     /// ```
-    #[clippy::version = "1.73.0"]
-    pub ITER_SKIP_ZERO,
-    correctness,
-    "disallows `.skip(0)`"
+    #[clippy::version = "1.39.0"]
+    pub SUSPICIOUS_MAP,
+    suspicious,
+    "suspicious usage of map"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `bool::then` in `Iterator::filter_map`.
+    /// Checks for the suspicious use of `OpenOptions::create()`
+    /// without an explicit `OpenOptions::truncate()`.
     ///
     /// ### Why is this bad?
-    /// This can be written with `filter` then `map` instead, which would reduce nesting and
-    /// separates the filtering from the transformation phase. This comes with no cost to
-    /// performance and is just cleaner.
-    ///
-    /// ### Limitations
-    /// Does not lint `bool::then_some`, as it eagerly evaluates its arguments rather than lazily.
-    /// This can create differing behavior, so better safe than sorry.
+    /// `create()` alone will either create a new file or open an
+    /// existing file. If the file already exists, it will be
+    /// overwritten when written to, but the file will not be
+    /// truncated by default.
+    /// If less data is written to the file
+    /// than it already contains, the remainder of the file will
+    /// remain unchanged, and the end of the file will contain old
+    /// data.
+    /// In most cases, one should either use `create_new` to ensure
+    /// the file is created from scratch, or ensure `truncate` is
+    /// called so that the truncation behaviour is explicit. `truncate(true)`
+    /// will ensure the file is entirely overwritten with new data, whereas
+    /// `truncate(false)` will explicitly keep the default behavior.
     ///
     /// ### Example
-    /// ```no_run
-    /// # fn really_expensive_fn(i: i32) -> i32 { i }
-    /// # let v = vec![];
-    /// _ = v.into_iter().filter_map(|i| (i % 2 == 0).then(|| really_expensive_fn(i)));
+    /// ```rust,no_run
+    /// use std::fs::OpenOptions;
+    ///
+    /// OpenOptions::new().create(true);
     /// ```
     /// Use instead:
-    /// ```no_run
-    /// # fn really_expensive_fn(i: i32) -> i32 { i }
-    /// # let v = vec![];
-    /// _ = v.into_iter().filter(|i| i % 2 == 0).map(|i| really_expensive_fn(i));
+    /// ```rust,no_run
+    /// use std::fs::OpenOptions;
+    ///
+    /// OpenOptions::new().create(true).truncate(true);
     /// ```
-    #[clippy::version = "1.73.0"]
-    pub FILTER_MAP_BOOL_THEN,
-    style,
-    "checks for usage of `bool::then` in `Iterator::filter_map`"
+    #[clippy::version = "1.77.0"]
+    pub SUSPICIOUS_OPEN_OPTIONS,
+    suspicious,
+    "suspicious combination of options for opening a file"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Looks for calls to `RwLock::write` where the lock is only used for reading.
+    /// Checks for calls to [`splitn`]
+    /// (https://doc.rust-lang.org/std/primitive.str.html#method.splitn) and
+    /// related functions with either zero or one splits.
     ///
     /// ### Why is this bad?
-    /// The write portion of `RwLock` is exclusive, meaning that no other thread
-    /// can access the lock while this writer is active.
+    /// These calls don't actually split the value and are
+    /// likely to be intended as a different number.
     ///
     /// ### Example
     /// ```no_run
-    /// use std::sync::RwLock;
-    /// fn assert_is_zero(lock: &RwLock<i32>) {
-    ///     let num = lock.write().unwrap();
-    ///     assert_eq!(*num, 0);
+    /// # let s = "";
+    /// for x in s.splitn(1, ":") {
+    ///     // ..
     /// }
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// use std::sync::RwLock;
-    /// fn assert_is_zero(lock: &RwLock<i32>) {
-    ///     let num = lock.read().unwrap();
-    ///     assert_eq!(*num, 0);
+    /// # let s = "";
+    /// for x in s.splitn(2, ":") {
+    ///     // ..
     /// }
     /// ```
-    #[clippy::version = "1.73.0"]
-    pub READONLY_WRITE_LOCK,
-    perf,
-    "acquiring a write lock when a read lock would work"
+    #[clippy::version = "1.54.0"]
+    pub SUSPICIOUS_SPLITN,
+    correctness,
+    "checks for `.splitn(0, ..)` and `.splitn(1, ..)`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Looks for iterator combinator calls such as `.take(x)` or `.skip(x)`
-    /// where `x` is greater than the amount of items that an iterator will produce.
+    /// Checks for the usage of `_.to_owned()`, on a `Cow<'_, _>`.
     ///
     /// ### Why is this bad?
-    /// Taking or skipping more items than there are in an iterator either creates an iterator
-    /// with all items from the original iterator or an iterator with no items at all.
-    /// This is most likely not what the user intended to do.
+    /// Calling `to_owned()` on a `Cow` creates a clone of the `Cow`
+    /// itself, without taking ownership of the `Cow` contents (i.e.
+    /// it's equivalent to calling `Cow::clone`).
+    /// The similarly named `into_owned` method, on the other hand,
+    /// clones the `Cow` contents, effectively turning any `Cow::Borrowed`
+    /// into a `Cow::Owned`.
+    ///
+    /// Given the potential ambiguity, consider replacing `to_owned`
+    /// with `clone` for better readability or, if getting a `Cow::Owned`
+    /// was the original intent, using `into_owned` instead.
     ///
     /// ### Example
     /// ```no_run
-    /// for _ in [1, 2, 3].iter().take(4) {}
+    /// # use std::borrow::Cow;
+    /// let s = "Hello world!";
+    /// let cow = Cow::Borrowed(s);
+    ///
+    /// let data = cow.to_owned();
+    /// assert!(matches!(data, Cow::Borrowed(_)))
     /// ```
     /// Use instead:
     /// ```no_run
-    /// for _ in [1, 2, 3].iter() {}
+    /// # use std::borrow::Cow;
+    /// let s = "Hello world!";
+    /// let cow = Cow::Borrowed(s);
+    ///
+    /// let data = cow.clone();
+    /// assert!(matches!(data, Cow::Borrowed(_)))
     /// ```
-    #[clippy::version = "1.74.0"]
-    pub ITER_OUT_OF_BOUNDS,
+    /// or
+    /// ```no_run
+    /// # use std::borrow::Cow;
+    /// let s = "Hello world!";
+    /// let cow = Cow::Borrowed(s);
+    ///
+    /// let _data: String = cow.into_owned();
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub SUSPICIOUS_TO_OWNED,
     suspicious,
-    "calls to `.take()` or `.skip()` that are out of bounds"
+    "calls to `to_owned` on a `Cow<'_, _>` might not do what they are expected"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Looks for calls to `Path::ends_with` calls where the argument looks like a file extension.
-    ///
-    /// By default, Clippy has a short list of known filenames that start with a dot
-    /// but aren't necessarily file extensions (e.g. the `.git` folder), which are allowed by default.
-    /// The `allowed-dotfiles` configuration can be used to allow additional
-    /// file extensions that Clippy should not lint.
+    /// Checks for usage of `std::mem::swap` with temporary values.
     ///
     /// ### Why is this bad?
-    /// This doesn't actually compare file extensions. Rather, `ends_with` compares the given argument
-    /// to the last **component** of the path and checks if it matches exactly.
+    /// Storing a new value in place of a temporary value which will
+    /// be dropped right after the `swap` is an inefficient way of performing
+    /// an assignment. The same result can be achieved by using a regular
+    /// assignment.
     ///
-    /// ### Known issues
-    /// File extensions are often at most three characters long, so this only lints in those cases
-    /// in an attempt to avoid false positives.
-    /// Any extension names longer than that are assumed to likely be real path components and are
-    /// therefore ignored.
+    /// ### Examples
+    /// ```no_run
+    /// fn replace_string(s: &mut String) {
+    ///     std::mem::swap(s, &mut String::from("replaced"));
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn replace_string(s: &mut String) {
+    ///     *s = String::from("replaced");
+    /// }
+    /// ```
+    ///
+    /// Also, swapping two temporary values has no effect, as they will
+    /// both be dropped right after swapping them. This is likely an indication
+    /// of a bug. For example, the following code swaps the references to
+    /// the last element of the vectors, instead of swapping the elements
+    /// themselves:
     ///
-    /// ### Example
     /// ```no_run
-    /// # use std::path::Path;
-    /// fn is_markdown(path: &Path) -> bool {
-    ///     path.ends_with(".md")
+    /// fn bug(v1: &mut [i32], v2: &mut [i32]) {
+    ///     // Incorrect: swapping temporary references (`&mut &mut` passed to swap)
+    ///     std::mem::swap(&mut v1.last_mut().unwrap(), &mut v2.last_mut().unwrap());
     /// }
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # use std::path::Path;
-    /// fn is_markdown(path: &Path) -> bool {
-    ///     path.extension().is_some_and(|ext| ext == "md")
+    /// fn correct(v1: &mut [i32], v2: &mut [i32]) {
+    ///     std::mem::swap(v1.last_mut().unwrap(), v2.last_mut().unwrap());
     /// }
     /// ```
-    #[clippy::version = "1.74.0"]
-    pub PATH_ENDS_WITH_EXT,
-    suspicious,
-    "attempting to compare file extensions using `Path::ends_with`"
+    #[clippy::version = "1.88.0"]
+    pub SWAP_WITH_TEMPORARY,
+    complexity,
+    "detect swap with a temporary value"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `as_str()` on a `String` chained with a method available on the `String` itself.
+    /// Looks for calls to `.type_id()` on a `Box<dyn _>`.
     ///
     /// ### Why is this bad?
-    /// The `as_str()` conversion is pointless and can be removed for simplicity and cleanliness.
+    /// This almost certainly does not do what the user expects and can lead to subtle bugs.
+    /// Calling `.type_id()` on a `Box<dyn Trait>` returns a fixed `TypeId` of the `Box` itself,
+    /// rather than returning the `TypeId` of the underlying type behind the trait object.
+    ///
+    /// For `Box<dyn Any>` specifically (and trait objects that have `Any` as its supertrait),
+    /// this lint will provide a suggestion, which is to dereference the receiver explicitly
+    /// to go from `Box<dyn Any>` to `dyn Any`.
+    /// This makes sure that `.type_id()` resolves to a dynamic call on the trait object
+    /// and not on the box.
+    ///
+    /// If the fixed `TypeId` of the `Box` is the intended behavior, it's better to be explicit about it
+    /// and write `TypeId::of::<Box<dyn Trait>>()`:
+    /// this makes it clear that a fixed `TypeId` is returned and not the `TypeId` of the implementor.
     ///
     /// ### Example
+    /// ```rust,ignore
+    /// use std::any::{Any, TypeId};
+    ///
+    /// let any_box: Box<dyn Any> = Box::new(42_i32);
+    /// assert_eq!(any_box.type_id(), TypeId::of::<i32>()); // ⚠️ this fails!
+    /// ```
+    /// Use instead:
     /// ```no_run
-    /// let owned_string = "This is a string".to_owned();
-    /// owned_string.as_str().as_bytes()
-    /// # ;
+    /// use std::any::{Any, TypeId};
+    ///
+    /// let any_box: Box<dyn Any> = Box::new(42_i32);
+    /// assert_eq!((*any_box).type_id(), TypeId::of::<i32>());
+    /// //          ^ dereference first, to call `type_id` on `dyn Any`
     /// ```
+    #[clippy::version = "1.73.0"]
+    pub TYPE_ID_ON_BOX,
+    suspicious,
+    "calling `.type_id()` on a boxed trait object"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `Read::bytes` on types which don't implement `BufRead`.
+    ///
+    /// ### Why is this bad?
+    /// The default implementation calls `read` for each byte, which can be very inefficient for data that's not in memory, such as `File`.
     ///
+    /// ### Example
+    /// ```no_run
+    /// use std::io::Read;
+    /// use std::fs::File;
+    /// let file = File::open("./bytes.txt").unwrap();
+    /// file.bytes();
+    /// ```
     /// Use instead:
     /// ```no_run
-    /// let owned_string = "This is a string".to_owned();
-    /// owned_string.as_bytes()
-    /// # ;
+    /// use std::io::{BufReader, Read};
+    /// use std::fs::File;
+    /// let file = BufReader::new(File::open("./bytes.txt").unwrap());
+    /// file.bytes();
     /// ```
-    #[clippy::version = "1.74.0"]
-    pub REDUNDANT_AS_STR,
-    complexity,
-    "`as_str` used to call a method on `str` that is also available on `String`"
+    #[clippy::version = "1.87.0"]
+    pub UNBUFFERED_BYTES,
+    perf,
+    "calling .bytes() is very inefficient when data is not in memory"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `waker.clone().wake()`
+    /// Checks for `MaybeUninit::uninit().assume_init()`.
     ///
     /// ### Why is this bad?
-    /// Cloning the waker is not necessary, `wake_by_ref()` enables the same operation
-    /// without extra cloning/dropping.
+    /// For most types, this is undefined behavior.
+    ///
+    /// ### Known problems
+    /// For now, we accept empty tuples and tuples / arrays
+    /// of `MaybeUninit`. There may be other types that allow uninitialized
+    /// data, but those are not yet rigorously defined.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// waker.clone().wake();
+    /// ```no_run
+    /// // Beware the UB
+    /// use std::mem::MaybeUninit;
+    ///
+    /// let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
     /// ```
-    /// Should be written
-    /// ```rust,ignore
-    /// waker.wake_by_ref();
+    ///
+    /// Note that the following is OK:
+    ///
+    /// ```no_run
+    /// use std::mem::MaybeUninit;
+    ///
+    /// let _: [MaybeUninit<bool>; 5] = unsafe {
+    ///     MaybeUninit::uninit().assume_init()
+    /// };
     /// ```
-    #[clippy::version = "1.75.0"]
-    pub WAKER_CLONE_WAKE,
-    perf,
-    "cloning a `Waker` only to wake it"
+    #[clippy::version = "1.39.0"]
+    pub UNINIT_ASSUMED_INIT,
+    correctness,
+    "`MaybeUninit::uninit().assume_init()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects `().hash(_)`.
+    ///
+    /// ### Why is this bad?
+    /// Hashing a unit value doesn't do anything as the implementation of `Hash` for `()` is a no-op.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::hash::Hash;
+    /// # use std::collections::hash_map::DefaultHasher;
+    /// # enum Foo { Empty, WithValue(u8) }
+    /// # use Foo::*;
+    /// # let mut state = DefaultHasher::new();
+    /// # let my_enum = Foo::Empty;
+    /// match my_enum {
+    /// 	Empty => ().hash(&mut state),
+    /// 	WithValue(x) => x.hash(&mut state),
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::hash::Hash;
+    /// # use std::collections::hash_map::DefaultHasher;
+    /// # enum Foo { Empty, WithValue(u8) }
+    /// # use Foo::*;
+    /// # let mut state = DefaultHasher::new();
+    /// # let my_enum = Foo::Empty;
+    /// match my_enum {
+    /// 	Empty => 0_u8.hash(&mut state),
+    /// 	WithValue(x) => x.hash(&mut state),
+    /// }
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub UNIT_HASH,
+    correctness,
+    "hashing a unit value, which does nothing"
 }
 
 declare_clippy_lint! {
@@ -3822,206 +4050,275 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `Path::join` that start with a path separator (`\\` or `/`).
+    /// Checks for `filter_map` calls that could be replaced by `filter` or `map`.
+    /// More specifically it checks if the closure provided is only performing one of the
+    /// filter or map operations and suggests the appropriate option.
     ///
     /// ### Why is this bad?
-    /// If the argument to `Path::join` starts with a separator, it will overwrite
-    /// the original path. If this is intentional, prefer using `Path::new` instead.
-    ///
-    /// Note the behavior is platform dependent. A leading `\\` will be accepted
-    /// on unix systems as part of the file name
-    ///
-    /// See [`Path::join`](https://doc.rust-lang.org/std/path/struct.Path.html#method.join)
+    /// Complexity. The intent is also clearer if only a single
+    /// operation is being performed.
     ///
     /// ### Example
-    /// ```rust
-    /// # use std::path::{Path, PathBuf};
-    /// let path = Path::new("/bin");
-    /// let joined_path = path.join("/sh");
-    /// assert_eq!(joined_path, PathBuf::from("/sh"));
-    /// ```
+    /// ```no_run
+    /// let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });
     ///
-    /// Use instead;
-    /// ```rust
-    /// # use std::path::{Path, PathBuf};
-    /// let path = Path::new("/bin");
+    /// // As there is no transformation of the argument this could be written as:
+    /// let _ = (0..3).filter(|&x| x > 2);
+    /// ```
     ///
-    /// // If this was unintentional, remove the leading separator
-    /// let joined_path = path.join("sh");
-    /// assert_eq!(joined_path, PathBuf::from("/bin/sh"));
+    /// ```no_run
+    /// let _ = (0..4).filter_map(|x| Some(x + 1));
     ///
-    /// // If this was intentional, create a new path instead
-    /// let new = Path::new("/sh");
-    /// assert_eq!(new, PathBuf::from("/sh"));
+    /// // As there is no conditional check on the argument this could be written as:
+    /// let _ = (0..4).map(|x| x + 1);
     /// ```
-    #[clippy::version = "1.76.0"]
-    pub JOIN_ABSOLUTE_PATHS,
-    suspicious,
-    "calls to `Path::join` which will overwrite the original path"
+    #[clippy::version = "1.31.0"]
+    pub UNNECESSARY_FILTER_MAP,
+    complexity,
+    "using `filter_map` when a more succinct alternative exists"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for iterators of `Result`s using `.filter(Result::is_ok).map(Result::unwrap)` that may
-    /// be replaced with a `.flatten()` call.
+    /// Checks for `find_map` calls that could be replaced by `find` or `map`. More
+    /// specifically it checks if the closure provided is only performing one of the
+    /// find or map operations and suggests the appropriate option.
     ///
     /// ### Why is this bad?
-    /// `Result` implements `IntoIterator<Item = T>`. This means that `Result` can be flattened
-    /// automatically without suspicious-looking `unwrap` calls.
+    /// Complexity. The intent is also clearer if only a single
+    /// operation is being performed.
     ///
     /// ### Example
     /// ```no_run
-    /// let _ = std::iter::empty::<Result<i32, ()>>().filter(Result::is_ok).map(Result::unwrap);
+    /// let _ = (0..3).find_map(|x| if x > 2 { Some(x) } else { None });
+    ///
+    /// // As there is no transformation of the argument this could be written as:
+    /// let _ = (0..3).find(|&x| x > 2);
     /// ```
-    /// Use instead:
+    ///
     /// ```no_run
-    /// let _ = std::iter::empty::<Result<i32, ()>>().flatten();
-    /// ```
-    #[clippy::version = "1.77.0"]
-    pub RESULT_FILTER_MAP,
+    /// let _ = (0..4).find_map(|x| Some(x + 1));
+    ///
+    /// // As there is no conditional check on the argument this could be written as:
+    /// let _ = (0..4).map(|x| x + 1).next();
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub UNNECESSARY_FIND_MAP,
     complexity,
-    "filtering `Result` for `Ok` then force-unwrapping, which can be one type-safe operation"
+    "using `find_map` when a more succinct alternative exists"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.filter(Option::is_some)` that may be replaced with a `.flatten()` call.
-    /// This lint will require additional changes to the follow-up calls as it affects the type.
+    /// Checks the usage of `.first().is_some()` or `.first().is_none()` to check if a slice is
+    /// empty.
     ///
     /// ### Why is this bad?
-    /// This pattern is often followed by manual unwrapping of the `Option`. The simplification
-    /// results in more readable and succinct code without the need for manual unwrapping.
+    /// Using `.is_empty()` is shorter and better communicates the intention.
     ///
     /// ### Example
     /// ```no_run
-    /// vec![Some(1)].into_iter().filter(Option::is_some);
-    ///
+    /// let v = vec![1, 2, 3];
+    /// if v.first().is_none() {
+    ///     // The vector is empty...
+    /// }
     /// ```
     /// Use instead:
     /// ```no_run
-    /// vec![Some(1)].into_iter().flatten();
+    /// let v = vec![1, 2, 3];
+    /// if v.is_empty() {
+    ///     // The vector is empty...
+    /// }
     /// ```
-    #[clippy::version = "1.77.0"]
-    pub ITER_FILTER_IS_SOME,
-    pedantic,
-    "filtering an iterator over `Option`s for `Some` can be achieved with `flatten`"
+    #[clippy::version = "1.83.0"]
+    pub UNNECESSARY_FIRST_THEN_CHECK,
+    complexity,
+    "calling `.first().is_some()` or `.first().is_none()` instead of `.is_empty()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.filter(Result::is_ok)` that may be replaced with a `.flatten()` call.
-    /// This lint will require additional changes to the follow-up calls as it affects the type.
+    /// Checks for usage of `fold` when a more succinct alternative exists.
+    /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`,
+    /// `sum` or `product`.
     ///
     /// ### Why is this bad?
-    /// This pattern is often followed by manual unwrapping of `Result`. The simplification
-    /// results in more readable and succinct code without the need for manual unwrapping.
+    /// Readability.
     ///
     /// ### Example
     /// ```no_run
-    /// vec![Ok::<i32, String>(1)].into_iter().filter(Result::is_ok);
-    ///
+    /// (0..3).fold(false, |acc, x| acc || x > 2);
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// vec![Ok::<i32, String>(1)].into_iter().flatten();
+    /// (0..3).any(|x| x > 2);
     /// ```
-    #[clippy::version = "1.77.0"]
-    pub ITER_FILTER_IS_OK,
-    pedantic,
-    "filtering an iterator over `Result`s for `Ok` can be achieved with `flatten`"
+    #[clippy::version = "pre 1.29.0"]
+    pub UNNECESSARY_FOLD,
+    style,
+    "using `fold` when a more succinct alternative exists"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `option.map(f).unwrap_or_default()` and `result.map(f).unwrap_or_default()` where `f` is a function or closure that returns the `bool` type.
-    ///
-    /// Also checks for equality comparisons like `option.map(f) == Some(true)` and `result.map(f) == Ok(true)`.
+    /// Checks the usage of `.get().is_some()` or `.get().is_none()` on std map types.
     ///
     /// ### Why is this bad?
-    /// Readability. These can be written more concisely as `option.is_some_and(f)` and `result.is_ok_and(f)`.
+    /// It can be done in one call with `.contains()`/`.contains_key()`.
     ///
     /// ### Example
     /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.map(|a| a > 10).unwrap_or_default();
-    /// result.map(|a| a > 10).unwrap_or_default();
-    ///
-    /// option.map(|a| a > 10) == Some(true);
-    /// result.map(|a| a > 10) == Ok(true);
-    /// option.map(|a| a > 10) != Some(true);
-    /// result.map(|a| a > 10) != Ok(true);
+    /// # use std::collections::HashSet;
+    /// let s: HashSet<String> = HashSet::new();
+    /// if s.get("a").is_some() {
+    ///     // code
+    /// }
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.is_some_and(|a| a > 10);
-    /// result.is_ok_and(|a| a > 10);
+    /// # use std::collections::HashSet;
+    /// let s: HashSet<String> = HashSet::new();
+    /// if s.contains("a") {
+    ///     // code
+    /// }
+    /// ```
+    #[clippy::version = "1.78.0"]
+    pub UNNECESSARY_GET_THEN_CHECK,
+    suspicious,
+    "calling `.get().is_some()` or `.get().is_none()` instead of `.contains()` or `.contains_key()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.collect::<Vec<String>>().join("")` on iterators.
     ///
-    /// option.is_some_and(|a| a > 10);
-    /// result.is_ok_and(|a| a > 10);
-    /// option.is_none_or(|a| a > 10);
-    /// !result.is_ok_and(|a| a > 10);
+    /// ### Why is this bad?
+    /// `.collect::<String>()` is more concise and might be more performant
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vector = vec!["hello",  "world"];
+    /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<Vec<String>>().join("");
+    /// println!("{}", output);
     /// ```
-    #[clippy::version = "1.77.0"]
-    pub MANUAL_IS_VARIANT_AND,
+    /// The correct use would be:
+    /// ```no_run
+    /// let vector = vec!["hello",  "world"];
+    /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<String>();
+    /// println!("{}", output);
+    /// ```
+    /// ### Known problems
+    /// While `.collect::<String>()` is sometimes more performant, there are cases where
+    /// using `.collect::<String>()` over `.collect::<Vec<String>>().join("")`
+    /// will prevent loop unrolling and will result in a negative performance impact.
+    ///
+    /// Additionally, differences have been observed between aarch64 and x86_64 assembly output,
+    /// with aarch64 tending to producing faster assembly in more cases when using `.collect::<String>()`
+    #[clippy::version = "1.61.0"]
+    pub UNNECESSARY_JOIN,
     pedantic,
-    "using `.map(f).unwrap_or_default()` or `.map(f) == Some/Ok(true)`, which are more succinctly expressed as `is_some_and(f)` or `is_ok_and(f)`"
+    "using `.collect::<Vec<String>>().join(\"\")` on an iterator"
 }
 
 declare_clippy_lint! {
     /// ### What it does
+    /// As the counterpart to `or_fun_call`, this lint looks for unnecessary
+    /// lazily evaluated closures on `Option` and `Result`.
     ///
-    /// Checks for usages of `str.trim().split("\n")` and `str.trim().split("\r\n")`.
+    /// This lint suggests changing the following functions, when eager evaluation results in
+    /// simpler code:
+    ///  - `unwrap_or_else` to `unwrap_or`
+    ///  - `and_then` to `and`
+    ///  - `or_else` to `or`
+    ///  - `get_or_insert_with` to `get_or_insert`
+    ///  - `ok_or_else` to `ok_or`
+    ///  - `then` to `then_some` (for msrv >= 1.62.0)
     ///
     /// ### Why is this bad?
+    /// Using eager evaluation is shorter and simpler in some cases.
     ///
-    /// Hard-coding the line endings makes the code less compatible. `str.lines` should be used instead.
+    /// ### Known problems
+    /// It is possible, but not recommended for `Deref` and `Index` to have
+    /// side effects. Eagerly evaluating them can change the semantics of the program.
     ///
     /// ### Example
     /// ```no_run
-    /// "some\ntext\nwith\nnewlines\n".trim().split('\n');
+    /// let opt: Option<u32> = None;
+    ///
+    /// opt.unwrap_or_else(|| 42);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// "some\ntext\nwith\nnewlines\n".lines();
+    /// let opt: Option<u32> = None;
+    ///
+    /// opt.unwrap_or(42);
     /// ```
+    #[clippy::version = "1.48.0"]
+    pub UNNECESSARY_LAZY_EVALUATIONS,
+    style,
+    "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.unwrap()` related calls on `Result`s and `Option`s that are constructed.
     ///
-    /// ### Known Problems
+    /// ### Why is this bad?
+    /// It is better to write the value directly without the indirection.
     ///
-    /// This lint cannot detect if the split is intentionally restricted to a single type of newline (`"\n"` or
-    /// `"\r\n"`), for example during the parsing of a specific file format in which precisely one newline type is
-    /// valid.
-    #[clippy::version = "1.77.0"]
-    pub STR_SPLIT_AT_NEWLINE,
-    pedantic,
-    "splitting a trimmed string at hard-coded newlines"
+    /// ### Examples
+    /// ```no_run
+    /// let val1 = Some(1).unwrap();
+    /// let val2 = Ok::<_, ()>(1).unwrap();
+    /// let val3 = Err::<(), _>(1).unwrap_err();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let val1 = 1;
+    /// let val2 = 1;
+    /// let val3 = 1;
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub UNNECESSARY_LITERAL_UNWRAP,
+    complexity,
+    "using `unwrap()` related calls on `Result` and `Option` constructors"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.as_ref().cloned()` and `.as_mut().cloned()` on `Option`s
+    /// Converts some constructs mapping an Enum value for equality comparison.
     ///
     /// ### Why is this bad?
-    /// This can be written more concisely by cloning the `Option` directly.
+    /// Calls such as `opt.map_or(false, |val| val == 5)` are needlessly long and cumbersome,
+    /// and can be reduced to, for example, `opt == Some(5)` assuming `opt` implements `PartialEq`.
+    /// Also, calls such as `opt.map_or(true, |val| val == 5)` can be reduced to
+    /// `opt.is_none_or(|val| val == 5)`.
+    /// This lint offers readability and conciseness improvements.
     ///
     /// ### Example
     /// ```no_run
-    /// fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> {
-    ///     bar.as_ref().cloned()
+    /// pub fn a(x: Option<i32>) -> (bool, bool) {
+    ///     (
+    ///         x.map_or(false, |n| n == 5),
+    ///         x.map_or(true, |n| n > 5),
+    ///     )
     /// }
     /// ```
     /// Use instead:
     /// ```no_run
-    /// fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> {
-    ///     bar.clone()
+    /// pub fn a(x: Option<i32>) -> (bool, bool) {
+    ///     (
+    ///         x == Some(5),
+    ///         x.is_none_or(|n| n > 5),
+    ///     )
     /// }
     /// ```
-    #[clippy::version = "1.77.0"]
-    pub OPTION_AS_REF_CLONED,
-    pedantic,
-    "cloning an `Option` via `as_ref().cloned()`"
+    #[clippy::version = "1.84.0"]
+    pub UNNECESSARY_MAP_OR,
+    style,
+    "reduce unnecessary calls to `.map_or(bool, …)`"
 }
 
 declare_clippy_lint! {
@@ -4049,6 +4346,30 @@ declare_clippy_lint! {
     "using 'min()/max()' when there is no need for it"
 }
 
+declare_clippy_lint! {
+    /// Checks for usage of `.map_or_else()` "map closure" for `Option` type.
+    ///
+    /// ### Why is this bad?
+    /// This can be written more concisely by using `unwrap_or_else()`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let k = 10;
+    /// let x: Option<u32> = Some(4);
+    /// let y = x.map_or_else(|| 2 * k, |n| n);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let k = 10;
+    /// let x: Option<u32> = Some(4);
+    /// let y = x.unwrap_or_else(|| 2 * k);
+    /// ```
+    #[clippy::version = "1.92.0"]
+    pub UNNECESSARY_OPTION_MAP_OR_ELSE,
+    suspicious,
+    "making no use of the \"map closure\" when calling `.map_or_else(|| 2 * k, |n| n)`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `.map_or_else()` "map closure" for `Result` type.
@@ -4076,679 +4397,514 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the manual creation of C strings (a string with a `NUL` byte at the end), either
-    /// through one of the `CStr` constructor functions, or more plainly by calling `.as_ptr()`
-    /// on a (byte) string literal with a hardcoded `\0` byte at the end.
+    /// Checks for usage of `Vec::sort_by` passing in a closure
+    /// which compares the two arguments, either directly or indirectly.
     ///
     /// ### Why is this bad?
-    /// This can be written more concisely using `c"str"` literals and is also less error-prone,
-    /// because the compiler checks for interior `NUL` bytes and the terminating `NUL` byte is inserted automatically.
+    /// It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if
+    /// possible) than to use `Vec::sort_by` and a more complicated
+    /// closure.
     ///
-    /// ### Example
-    /// ```no_run
-    /// # use std::ffi::CStr;
-    /// # mod libc { pub unsafe fn puts(_: *const i8) {} }
-    /// fn needs_cstr(_: &CStr) {}
+    /// ### Known problems
+    /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't already
+    /// imported by a use statement, then it will need to be added manually.
     ///
-    /// needs_cstr(CStr::from_bytes_with_nul(b"Hello\0").unwrap());
-    /// unsafe { libc::puts("World\0".as_ptr().cast()) }
+    /// ### Example
+    /// ```no_run
+    /// # struct A;
+    /// # impl A { fn foo(&self) {} }
+    /// # let mut vec: Vec<A> = Vec::new();
+    /// vec.sort_by(|a, b| a.foo().cmp(&b.foo()));
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # use std::ffi::CStr;
-    /// # mod libc { pub unsafe fn puts(_: *const i8) {} }
-    /// fn needs_cstr(_: &CStr) {}
-    ///
-    /// needs_cstr(c"Hello");
-    /// unsafe { libc::puts(c"World".as_ptr()) }
+    /// # struct A;
+    /// # impl A { fn foo(&self) {} }
+    /// # let mut vec: Vec<A> = Vec::new();
+    /// vec.sort_by_key(|a| a.foo());
     /// ```
-    #[clippy::version = "1.78.0"]
-    pub MANUAL_C_STR_LITERALS,
+    #[clippy::version = "1.46.0"]
+    pub UNNECESSARY_SORT_BY,
     complexity,
-    r#"creating a `CStr` through functions when `c""` literals can be used"#
+    "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks the usage of `.get().is_some()` or `.get().is_none()` on std map types.
+    /// Checks for unnecessary calls to [`ToOwned::to_owned`](https://doc.rust-lang.org/std/borrow/trait.ToOwned.html#tymethod.to_owned)
+    /// and other `to_owned`-like functions.
     ///
     /// ### Why is this bad?
-    /// It can be done in one call with `.contains()`/`.contains_key()`.
+    /// The unnecessary calls result in useless allocations.
+    ///
+    /// ### Known problems
+    /// `unnecessary_to_owned` can falsely trigger if `IntoIterator::into_iter` is applied to an
+    /// owned copy of a resource and the resource is later used mutably. See
+    /// [#8148](https://github.com/rust-lang/rust-clippy/issues/8148).
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// let s: HashSet<String> = HashSet::new();
-    /// if s.get("a").is_some() {
-    ///     // code
-    /// }
+    /// let path = std::path::Path::new("x");
+    /// foo(&path.to_string_lossy().to_string());
+    /// fn foo(s: &str) {}
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # use std::collections::HashSet;
-    /// let s: HashSet<String> = HashSet::new();
-    /// if s.contains("a") {
-    ///     // code
-    /// }
+    /// let path = std::path::Path::new("x");
+    /// foo(&path.to_string_lossy());
+    /// fn foo(s: &str) {}
     /// ```
-    #[clippy::version = "1.78.0"]
-    pub UNNECESSARY_GET_THEN_CHECK,
-    suspicious,
-    "calling `.get().is_some()` or `.get().is_none()` instead of `.contains()` or `.contains_key()`"
+    #[clippy::version = "1.59.0"]
+    pub UNNECESSARY_TO_OWNED,
+    perf,
+    "unnecessary calls to `to_owned`-like functions"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// It identifies calls to `.is_empty()` on constant values.
+    /// Checks for usages of the following functions with an argument that constructs a default value
+    /// (e.g., `Default::default` or `String::new`):
+    /// - `unwrap_or`
+    /// - `unwrap_or_else`
+    /// - `or_insert`
+    /// - `or_insert_with`
     ///
     /// ### Why is this bad?
-    /// String literals and constant values are known at compile time. Checking if they
-    /// are empty will always return the same value. This might not be the intention of
-    /// the expression.
+    /// Readability. Using `unwrap_or_default` in place of `unwrap_or`/`unwrap_or_else`, or `or_default`
+    /// in place of `or_insert`/`or_insert_with`, is simpler and more concise.
     ///
-    /// ### Example
+    /// ### Known problems
+    /// In some cases, the argument of `unwrap_or`, etc. is needed for type inference. The lint uses a
+    /// heuristic to try to identify such cases. However, the heuristic can produce false negatives.
+    ///
+    /// ### Examples
     /// ```no_run
-    /// let value = "";
-    /// if value.is_empty() {
-    ///     println!("the string is empty");
-    /// }
+    /// # let x = Some(1);
+    /// # let mut map = std::collections::HashMap::<u64, String>::new();
+    /// x.unwrap_or(Default::default());
+    /// map.entry(42).or_insert_with(String::new);
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// println!("the string is empty");
+    /// # let x = Some(1);
+    /// # let mut map = std::collections::HashMap::<u64, String>::new();
+    /// x.unwrap_or_default();
+    /// map.entry(42).or_default();
     /// ```
-    #[clippy::version = "1.79.0"]
-    pub CONST_IS_EMPTY,
-    suspicious,
-    "is_empty() called on strings known at compile time"
+    #[clippy::version = "1.56.0"]
+    pub UNWRAP_OR_DEFAULT,
+    style,
+    "using `.unwrap_or`, etc. with an argument that constructs a default value"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Converts some constructs mapping an Enum value for equality comparison.
+    /// Checks for `.unwrap()` or `.unwrap_err()` calls on `Result`s and `.unwrap()` call on `Option`s.
     ///
-    /// ### Why is this bad?
-    /// Calls such as `opt.map_or(false, |val| val == 5)` are needlessly long and cumbersome,
-    /// and can be reduced to, for example, `opt == Some(5)` assuming `opt` implements `PartialEq`.
-    /// Also, calls such as `opt.map_or(true, |val| val == 5)` can be reduced to
-    /// `opt.is_none_or(|val| val == 5)`.
-    /// This lint offers readability and conciseness improvements.
+    /// ### Why restrict this?
+    /// It is better to handle the `None` or `Err` case,
+    /// or at least call `.expect(_)` with a more helpful message. Still, for a lot of
+    /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
+    /// `Allow` by default.
     ///
-    /// ### Example
+    /// `result.unwrap()` will let the thread panic on `Err` values.
+    /// Normally, you want to implement more sophisticated error handling,
+    /// and propagate errors upwards with `?` operator.
+    ///
+    /// Even if you want to panic on errors, not all `Error`s implement good
+    /// messages on display. Therefore, it may be beneficial to look at the places
+    /// where they may get displayed. Activate this lint to do just that.
+    ///
+    /// ### Examples
     /// ```no_run
-    /// pub fn a(x: Option<i32>) -> (bool, bool) {
-    ///     (
-    ///         x.map_or(false, |n| n == 5),
-    ///         x.map_or(true, |n| n > 5),
-    ///     )
-    /// }
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.unwrap();
+    /// result.unwrap();
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// pub fn a(x: Option<i32>) -> (bool, bool) {
-    ///     (
-    ///         x == Some(5),
-    ///         x.is_none_or(|n| n > 5),
-    ///     )
-    /// }
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.expect("more helpful message");
+    /// result.expect("more helpful message");
     /// ```
-    #[clippy::version = "1.84.0"]
-    pub UNNECESSARY_MAP_OR,
-    style,
-    "reduce unnecessary calls to `.map_or(bool, …)`"
+    ///
+    /// If [expect_used](#expect_used) is enabled, instead:
+    /// ```rust,ignore
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option?;
+    ///
+    /// // or
+    ///
+    /// result?;
+    /// ```
+    #[clippy::version = "1.45.0"]
+    pub UNWRAP_USED,
+    restriction,
+    "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks if an iterator is used to check if a string is ascii.
+    /// Checks for usage of `.as_ref()` or `.as_mut()` where the
+    /// types before and after the call are the same.
     ///
     /// ### Why is this bad?
-    /// The `str` type already implements the `is_ascii` method.
+    /// The call is unnecessary.
     ///
     /// ### Example
     /// ```no_run
-    /// "foo".chars().all(|c| c.is_ascii());
+    /// # fn do_stuff(x: &[i32]) {}
+    /// let x: &[i32] = &[1, 2, 3, 4, 5];
+    /// do_stuff(x.as_ref());
     /// ```
-    /// Use instead:
+    /// The correct use would be:
     /// ```no_run
-    /// "foo".is_ascii();
+    /// # fn do_stuff(x: &[i32]) {}
+    /// let x: &[i32] = &[1, 2, 3, 4, 5];
+    /// do_stuff(x);
     /// ```
-    #[clippy::version = "1.81.0"]
-    pub NEEDLESS_CHARACTER_ITERATION,
-    suspicious,
-    "is_ascii() called on a char iterator"
+    #[clippy::version = "pre 1.29.0"]
+    pub USELESS_ASREF,
+    complexity,
+    "using `as_ref` where the types before and after the call are the same"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for uses of `map` which return the original item.
+    ///
+    /// Checks for `NonZero*::new_unchecked()` being used in a `const` context.
     ///
     /// ### Why is this bad?
-    /// `inspect` is both clearer in intent and shorter.
+    ///
+    /// Using `NonZero*::new_unchecked()` is an `unsafe` function and requires an `unsafe` context. When used in a
+    /// context evaluated at compilation time, `NonZero*::new().unwrap()` will provide the same result with identical
+    /// runtime performances while not requiring `unsafe`.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = Some(0).map(|x| { println!("{x}"); x });
+    /// use std::num::NonZeroUsize;
+    /// const PLAYERS: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked(3) };
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let x = Some(0).inspect(|x| println!("{x}"));
+    /// use std::num::NonZeroUsize;
+    /// const PLAYERS: NonZeroUsize = NonZeroUsize::new(3).unwrap();
     /// ```
-    #[clippy::version = "1.81.0"]
-    pub MANUAL_INSPECT,
+    #[clippy::version = "1.86.0"]
+    pub USELESS_NONZERO_NEW_UNCHECKED,
     complexity,
-    "use of `map` returning the original item"
+    "using `NonZero::new_unchecked()` in a `const` context"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks the usage of `.first().is_some()` or `.first().is_none()` to check if a slice is
-    /// empty.
+    /// Finds occurrences of `Vec::resize(0, an_int)`
     ///
     /// ### Why is this bad?
-    /// Using `.is_empty()` is shorter and better communicates the intention.
+    /// This is probably an argument inversion mistake.
     ///
     /// ### Example
     /// ```no_run
-    /// let v = vec![1, 2, 3];
-    /// if v.first().is_none() {
-    ///     // The vector is empty...
-    /// }
+    /// vec![1, 2, 3, 4, 5].resize(0, 5)
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// let v = vec![1, 2, 3];
-    /// if v.is_empty() {
-    ///     // The vector is empty...
-    /// }
+    /// vec![1, 2, 3, 4, 5].clear()
     /// ```
-    #[clippy::version = "1.83.0"]
-    pub UNNECESSARY_FIRST_THEN_CHECK,
-    complexity,
-    "calling `.first().is_some()` or `.first().is_none()` instead of `.is_empty()`"
-}
-
-declare_clippy_lint! {
-   /// ### What it does
-   /// It detects useless calls to `str::as_bytes()` before calling `len()` or `is_empty()`.
-   ///
-   /// ### Why is this bad?
-   /// The `len()` and `is_empty()` methods are also directly available on strings, and they
-   /// return identical results. In particular, `len()` on a string returns the number of
-   /// bytes.
-   ///
-   /// ### Example
-   /// ```
-   /// let len = "some string".as_bytes().len();
-   /// let b = "some string".as_bytes().is_empty();
-   /// ```
-   /// Use instead:
-   /// ```
-   /// let len = "some string".len();
-   /// let b = "some string".is_empty();
-   /// ```
-   #[clippy::version = "1.84.0"]
-   pub NEEDLESS_AS_BYTES,
-   complexity,
-   "detect useless calls to `as_bytes()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.map(…)`, followed by `.all(identity)` or `.any(identity)`.
-    ///
-    /// ### Why is this bad?
-    /// The `.all(…)` or `.any(…)` methods can be called directly in place of `.map(…)`.
-    ///
-    /// ### Example
-    /// ```
-    /// # let mut v = [""];
-    /// let e1 = v.iter().map(|s| s.is_empty()).all(|a| a);
-    /// let e2 = v.iter().map(|s| s.is_empty()).any(std::convert::identity);
-    /// ```
-    /// Use instead:
-    /// ```
-    /// # let mut v = [""];
-    /// let e1 = v.iter().all(|s| s.is_empty());
-    /// let e2 = v.iter().any(|s| s.is_empty());
-    /// ```
-    #[clippy::version = "1.84.0"]
-    pub MAP_ALL_ANY_IDENTITY,
-    complexity,
-    "combine `.map(_)` followed by `.all(identity)`/`.any(identity)` into a single call"
+    #[clippy::version = "1.46.0"]
+    pub VEC_RESIZE_TO_ZERO,
+    correctness,
+    "emptying a vector with `resize(0, an_int)` instead of `clear()` is probably an argument inversion mistake"
 }
 
 declare_clippy_lint! {
     /// ### What it does
+    /// Checks for usage of File::read_to_end and File::read_to_string.
     ///
-    /// Checks for `Iterator::map` over ranges without using the parameter which
-    /// could be more clearly expressed using `std::iter::repeat(...).take(...)`
-    /// or `std::iter::repeat_n`.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// It expresses the intent more clearly to `take` the correct number of times
-    /// from a generating function than to apply a closure to each number in a
-    /// range only to discard them.
+    /// ### Why restrict this?
+    /// `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.
+    /// See also: [fs::read docs](https://doc.rust-lang.org/std/fs/fn.read.html), [fs::read_to_string docs](https://doc.rust-lang.org/std/fs/fn.read_to_string.html)
     ///
     /// ### Example
-    ///
-    /// ```no_run
-    /// let random_numbers : Vec<_> = (0..10).map(|_| { 3 + 1 }).collect();
+    /// ```rust,no_run
+    /// # use std::io::Read;
+    /// # use std::fs::File;
+    /// let mut f = File::open("foo.txt").unwrap();
+    /// let mut bytes = Vec::new();
+    /// f.read_to_end(&mut bytes).unwrap();
     /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let f : Vec<_> = std::iter::repeat( 3 + 1 ).take(10).collect();
+    /// Can be written more concisely as
+    /// ```rust,no_run
+    /// # use std::fs;
+    /// let mut bytes = fs::read("foo.txt").unwrap();
     /// ```
-    ///
-    /// ### Known Issues
-    ///
-    /// This lint may suggest replacing a `Map<Range>` with a `Take<RepeatWith>`.
-    /// The former implements some traits that the latter does not, such as
-    /// `DoubleEndedIterator`.
-    #[clippy::version = "1.84.0"]
-    pub MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
+    #[clippy::version = "1.44.0"]
+    pub VERBOSE_FILE_READS,
     restriction,
-    "map of a trivial closure (not dependent on parameter) over a range"
+    "use of `File::read_to_end` or `File::read_to_string`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Checks for `Iterator::last` being called on a  `DoubleEndedIterator`, which can be replaced
-    /// with `DoubleEndedIterator::next_back`.
+    /// Checks for usage of `waker.clone().wake()`
     ///
     /// ### Why is this bad?
-    ///
-    /// `Iterator::last` is implemented by consuming the iterator, which is unnecessary if
-    /// the iterator is a `DoubleEndedIterator`. Since Rust traits do not allow specialization,
-    /// `Iterator::last` cannot be optimized for `DoubleEndedIterator`.
+    /// Cloning the waker is not necessary, `wake_by_ref()` enables the same operation
+    /// without extra cloning/dropping.
     ///
     /// ### Example
-    /// ```no_run
-    /// let last_arg = "echo hello world".split(' ').last();
+    /// ```rust,ignore
+    /// waker.clone().wake();
     /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let last_arg = "echo hello world".split(' ').next_back();
+    /// Should be written
+    /// ```rust,ignore
+    /// waker.wake_by_ref();
     /// ```
-    #[clippy::version = "1.86.0"]
-    pub DOUBLE_ENDED_ITERATOR_LAST,
+    #[clippy::version = "1.75.0"]
+    pub WAKER_CLONE_WAKE,
     perf,
-    "using `Iterator::last` on a `DoubleEndedIterator`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for `NonZero*::new_unchecked()` being used in a `const` context.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// Using `NonZero*::new_unchecked()` is an `unsafe` function and requires an `unsafe` context. When used in a
-    /// context evaluated at compilation time, `NonZero*::new().unwrap()` will provide the same result with identical
-    /// runtime performances while not requiring `unsafe`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// use std::num::NonZeroUsize;
-    /// const PLAYERS: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked(3) };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::num::NonZeroUsize;
-    /// const PLAYERS: NonZeroUsize = NonZeroUsize::new(3).unwrap();
-    /// ```
-    #[clippy::version = "1.86.0"]
-    pub USELESS_NONZERO_NEW_UNCHECKED,
-    complexity,
-    "using `NonZero::new_unchecked()` in a `const` context"
+    "cloning a `Waker` only to wake it"
 }
 
 declare_clippy_lint! {
     /// ### What it does
+    /// Checks for methods with certain name prefixes or suffixes, and which
+    /// do not adhere to standard conventions regarding how `self` is taken.
+    /// The actual rules are:
     ///
-    /// Checks for `repeat().take()` that can be replaced with `repeat_n()`.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// Using `repeat_n()` is more concise and clearer. Also, `repeat_n()` is sometimes faster than `repeat().take()` when the type of the element is non-trivial to clone because the original value can be reused for the last `.next()` call rather than always cloning.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = std::iter::repeat(10).take(3);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let _ = std::iter::repeat_n(10, 3);
-    /// ```
-    #[clippy::version = "1.86.0"]
-    pub MANUAL_REPEAT_N,
-    style,
-    "detect `repeat().take()` that can be replaced with `repeat_n()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for string slices immediately followed by `as_bytes`.
+    /// |Prefix |Postfix     |`self` taken                   | `self` type  |
+    /// |-------|------------|-------------------------------|--------------|
+    /// |`as_`  | none       |`&self` or `&mut self`         | any          |
+    /// |`from_`| none       | none                          | any          |
+    /// |`into_`| none       |`self`                         | any          |
+    /// |`is_`  | none       |`&mut self` or `&self` or none | any          |
+    /// |`to_`  | `_mut`     |`&mut self`                    | any          |
+    /// |`to_`  | not `_mut` |`self`                         | `Copy`       |
+    /// |`to_`  | not `_mut` |`&self`                        | not `Copy`   |
     ///
-    /// ### Why is this bad?
-    /// It involves doing an unnecessary UTF-8 alignment check which is less efficient, and can cause a panic.
+    /// Note: Clippy doesn't trigger methods with `to_` prefix in:
+    /// - Traits definition.
+    /// Clippy can not tell if a type that implements a trait is `Copy` or not.
+    /// - Traits implementation, when `&self` is taken.
+    /// The method signature is controlled by the trait and often `&self` is required for all types that implement the trait
+    /// (see e.g. the `std::string::ToString` trait).
     ///
-    /// ### Known problems
-    /// In some cases, the UTF-8 validation and potential panic from string slicing may be required for
-    /// the code's correctness. If you need to ensure the slice boundaries fall on valid UTF-8 character
-    /// boundaries, the original form (`s[1..5].as_bytes()`) should be preferred.
+    /// Clippy allows `Pin<&Self>` and `Pin<&mut Self>` if `&self` and `&mut self` is required.
     ///
-    /// ### Example
-    /// ```rust
-    /// let s = "Lorem ipsum";
-    /// s[1..5].as_bytes();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let s = "Lorem ipsum";
-    /// &s.as_bytes()[1..5];
-    /// ```
-     #[clippy::version = "1.86.0"]
-     pub SLICED_STRING_AS_BYTES,
-     perf,
-     "slicing a string and immediately calling as_bytes is less efficient and can lead to panics"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detect functions that end with `Option::and_then` or `Result::and_then`, and suggest using
-    /// the `?` operator instead.
+    /// Please find more info here:
+    /// https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
     ///
     /// ### Why is this bad?
-    /// The `and_then` method is used to chain a computation that returns an `Option` or a `Result`.
-    /// This can be replaced with the `?` operator, which is more concise and idiomatic.
+    /// Consistency breeds readability. If you follow the
+    /// conventions, your users won't be surprised that they, e.g., need to supply a
+    /// mutable reference to a `as_..` function.
     ///
     /// ### Example
-    ///
     /// ```no_run
-    /// fn test(opt: Option<i32>) -> Option<i32> {
-    ///     opt.and_then(|n| {
-    ///         if n > 1 {
-    ///             Some(n + 1)
-    ///         } else {
-    ///             None
-    ///        }
-    ///     })
+    /// # struct X;
+    /// impl X {
+    ///     fn as_str(self) -> &'static str {
+    ///         // ..
+    /// # ""
+    ///     }
     /// }
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// fn test(opt: Option<i32>) -> Option<i32> {
-    ///     let n = opt?;
-    ///     if n > 1 {
-    ///         Some(n + 1)
-    ///     } else {
-    ///         None
+    /// # struct X;
+    /// impl X {
+    ///     fn as_str(&self) -> &'static str {
+    ///         // ..
+    /// # ""
     ///     }
     /// }
     /// ```
-    #[clippy::version = "1.86.0"]
-    pub RETURN_AND_THEN,
-    restriction,
-    "using `Option::and_then` or `Result::and_then` to chain a computation that returns an `Option` or a `Result`"
+    #[clippy::version = "pre 1.29.0"]
+    pub WRONG_SELF_CONVENTION,
+    style,
+    "defining a method named with an established prefix (like \"into_\") that takes `self` with the wrong convention"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `Read::bytes` on types which don't implement `BufRead`.
+    /// Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to
+    /// zero-sized types
     ///
     /// ### Why is this bad?
-    /// The default implementation calls `read` for each byte, which can be very inefficient for data that's not in memory, such as `File`.
+    /// This is a no-op, and likely unintended
     ///
     /// ### Example
     /// ```no_run
-    /// use std::io::Read;
-    /// use std::fs::File;
-    /// let file = File::open("./bytes.txt").unwrap();
-    /// file.bytes();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::io::{BufReader, Read};
-    /// use std::fs::File;
-    /// let file = BufReader::new(File::open("./bytes.txt").unwrap());
-    /// file.bytes();
+    /// unsafe { (&() as *const ()).offset(1) };
     /// ```
-    #[clippy::version = "1.87.0"]
-    pub UNBUFFERED_BYTES,
-    perf,
-    "calling .bytes() is very inefficient when data is not in memory"
+    #[clippy::version = "1.41.0"]
+    pub ZST_OFFSET,
+    correctness,
+    "Check for offset calculations on raw pointers to zero-sized types"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `iter().any()` on slices when it can be replaced with `contains()` and suggests doing so.
-    ///
-    /// ### Why is this bad?
-    /// `contains()` is more concise and idiomatic, while also being faster in some cases.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo(values: &[u8]) -> bool {
-    ///     values.iter().any(|&v| v == 10)
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn foo(values: &[u8]) -> bool {
-    ///     values.contains(&10)
-    /// }
-    /// ```
-    #[clippy::version = "1.87.0"]
-    pub MANUAL_CONTAINS,
-    perf,
-    "unnecessary `iter().any()` on slices that can be replaced with `contains()`"
-}
-
-declare_clippy_lint! {
-    /// This lint warns on calling `io::Error::new(..)` with a kind of
-    /// `io::ErrorKind::Other`.
-    ///
-    /// ### Why is this bad?
-    /// Since Rust 1.74, there's the `io::Error::other(_)` shortcut.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// use std::io;
-    /// let _ = io::Error::new(io::ErrorKind::Other, "bad".to_string());
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let _ = std::io::Error::other("bad".to_string());
-    /// ```
-    #[clippy::version = "1.87.0"]
-    pub IO_OTHER_ERROR,
-    style,
-    "calling `std::io::Error::new(std::io::ErrorKind::Other, _)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `std::mem::swap` with temporary values.
-    ///
-    /// ### Why is this bad?
-    /// Storing a new value in place of a temporary value which will
-    /// be dropped right after the `swap` is an inefficient way of performing
-    /// an assignment. The same result can be achieved by using a regular
-    /// assignment.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// fn replace_string(s: &mut String) {
-    ///     std::mem::swap(s, &mut String::from("replaced"));
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn replace_string(s: &mut String) {
-    ///     *s = String::from("replaced");
-    /// }
-    /// ```
-    ///
-    /// Also, swapping two temporary values has no effect, as they will
-    /// both be dropped right after swapping them. This is likely an indication
-    /// of a bug. For example, the following code swaps the references to
-    /// the last element of the vectors, instead of swapping the elements
-    /// themselves:
-    ///
-    /// ```no_run
-    /// fn bug(v1: &mut [i32], v2: &mut [i32]) {
-    ///     // Incorrect: swapping temporary references (`&mut &mut` passed to swap)
-    ///     std::mem::swap(&mut v1.last_mut().unwrap(), &mut v2.last_mut().unwrap());
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// fn correct(v1: &mut [i32], v2: &mut [i32]) {
-    ///     std::mem::swap(v1.last_mut().unwrap(), v2.last_mut().unwrap());
-    /// }
-    /// ```
-    #[clippy::version = "1.88.0"]
-    pub SWAP_WITH_TEMPORARY,
-    complexity,
-    "detect swap with a temporary value"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for IP addresses that could be replaced with predefined constants such as
-    /// `Ipv4Addr::new(127, 0, 0, 1)` instead of using the appropriate constants.
-    ///
-    /// ### Why is this bad?
-    /// Using specific IP addresses like `127.0.0.1` or `::1` is less clear and less maintainable than using the
-    /// predefined constants `Ipv4Addr::LOCALHOST` or `Ipv6Addr::LOCALHOST`. These constants improve code
-    /// readability, make the intent explicit, and are less error-prone.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// use std::net::{Ipv4Addr, Ipv6Addr};
-    ///
-    /// // IPv4 loopback
-    /// let addr_v4 = Ipv4Addr::new(127, 0, 0, 1);
-    ///
-    /// // IPv6 loopback
-    /// let addr_v6 = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// use std::net::{Ipv4Addr, Ipv6Addr};
-    ///
-    /// // IPv4 loopback
-    /// let addr_v4 = Ipv4Addr::LOCALHOST;
-    ///
-    /// // IPv6 loopback
-    /// let addr_v6 = Ipv6Addr::LOCALHOST;
-    /// ```
-    #[clippy::version = "1.89.0"]
-    pub IP_CONSTANT,
-    pedantic,
-    "hardcoded localhost IP address"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `Iterator::cloned` where the original value could be used
-    /// instead.
-    ///
-    /// ### Why is this bad?
-    /// It is not always possible for the compiler to eliminate useless allocations and
-    /// deallocations generated by redundant `clone()`s.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let x = vec![String::new()];
-    /// let _ = x.iter().cloned().map(|x| x.len());
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let x = vec![String::new()];
-    /// let _ = x.iter().map(|x| x.len());
-    /// ```
-    #[clippy::version = "1.92.0"]
-    pub REDUNDANT_ITER_CLONED,
-    perf,
-    "detects redundant calls to `Iterator::cloned`"
-}
-
-declare_clippy_lint! {
-    /// Checks for usage of `.map_or_else()` "map closure" for `Option` type.
-    ///
-    /// ### Why is this bad?
-    /// This can be written more concisely by using `unwrap_or_else()`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let k = 10;
-    /// let x: Option<u32> = Some(4);
-    /// let y = x.map_or_else(|| 2 * k, |n| n);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let k = 10;
-    /// let x: Option<u32> = Some(4);
-    /// let y = x.unwrap_or_else(|| 2 * k);
-    /// ```
-    #[clippy::version = "1.92.0"]
-    pub UNNECESSARY_OPTION_MAP_OR_ELSE,
-    suspicious,
-    "making no use of the \"map closure\" when calling `.map_or_else(|| 2 * k, |n| n)`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `lines.filter_map(Result::ok)` or `lines.flat_map(Result::ok)`
-    /// when `lines` has type `std::io::Lines`.
-    ///
-    /// ### Why is this bad?
-    /// `Lines` instances might produce a never-ending stream of `Err`, in which case
-    /// `filter_map(Result::ok)` will enter an infinite loop while waiting for an
-    /// `Ok` variant. Calling `next()` once is sufficient to enter the infinite loop,
-    /// even in the absence of explicit loops in the user code.
-    ///
-    /// This situation can arise when working with user-provided paths. On some platforms,
-    /// `std::fs::File::open(path)` might return `Ok(fs)` even when `path` is a directory,
-    /// but any later attempt to read from `fs` will return an error.
-    ///
-    /// ### Known problems
-    /// This lint suggests replacing `filter_map()` or `flat_map()` applied to a `Lines`
-    /// instance in all cases. There are two cases where the suggestion might not be
-    /// appropriate or necessary:
-    ///
-    /// - If the `Lines` instance can never produce any error, or if an error is produced
-    ///   only once just before terminating the iterator, using `map_while()` is not
-    ///   necessary but will not do any harm.
-    /// - If the `Lines` instance can produce intermittent errors then recover and produce
-    ///   successful results, using `map_while()` would stop at the first error.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # use std::{fs::File, io::{self, BufRead, BufReader}};
-    /// # let _ = || -> io::Result<()> {
-    /// let mut lines = BufReader::new(File::open("some-path")?).lines().filter_map(Result::ok);
-    /// // If "some-path" points to a directory, the next statement never terminates:
-    /// let first_line: Option<String> = lines.next();
-    /// # Ok(()) };
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # use std::{fs::File, io::{self, BufRead, BufReader}};
-    /// # let _ = || -> io::Result<()> {
-    /// let mut lines = BufReader::new(File::open("some-path")?).lines().map_while(Result::ok);
-    /// let first_line: Option<String> = lines.next();
-    /// # Ok(()) };
-    /// ```
-    #[clippy::version = "1.70.0"]
-    pub LINES_FILTER_MAP_OK,
-    suspicious,
-    "filtering `std::io::Lines` with `filter_map()`, `flat_map()`, or `flatten()` might cause an infinite loop"
-}
+impl_lint_pass!(Methods => [
+    BIND_INSTEAD_OF_MAP,
+    BYTES_COUNT_TO_LEN,
+    BYTES_NTH,
+    CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    CHARS_LAST_CMP,
+    CHARS_NEXT_CMP,
+    CLEAR_WITH_DRAIN,
+    CLONED_INSTEAD_OF_COPIED,
+    CLONE_ON_COPY,
+    CLONE_ON_REF_PTR,
+    COLLAPSIBLE_STR_REPLACE,
+    CONST_IS_EMPTY,
+    DOUBLE_ENDED_ITERATOR_LAST,
+    DRAIN_COLLECT,
+    ERR_EXPECT,
+    EXPECT_FUN_CALL,
+    EXPECT_USED,
+    EXTEND_WITH_DRAIN,
+    FILETYPE_IS_FILE,
+    FILTER_MAP_BOOL_THEN,
+    FILTER_MAP_IDENTITY,
+    FILTER_MAP_NEXT,
+    FILTER_NEXT,
+    FLAT_MAP_IDENTITY,
+    FLAT_MAP_OPTION,
+    FORMAT_COLLECT,
+    FROM_ITER_INSTEAD_OF_COLLECT,
+    GET_FIRST,
+    GET_LAST_WITH_LEN,
+    GET_UNWRAP,
+    IMPLICIT_CLONE,
+    INEFFICIENT_TO_STRING,
+    INSPECT_FOR_EACH,
+    INTO_ITER_ON_REF,
+    IO_OTHER_ERROR,
+    IP_CONSTANT,
+    IS_DIGIT_ASCII_RADIX,
+    ITERATOR_STEP_BY_ZERO,
+    ITER_CLONED_COLLECT,
+    ITER_COUNT,
+    ITER_FILTER_IS_OK,
+    ITER_FILTER_IS_SOME,
+    ITER_KV_MAP,
+    ITER_NEXT_SLICE,
+    ITER_NTH,
+    ITER_NTH_ZERO,
+    ITER_ON_EMPTY_COLLECTIONS,
+    ITER_ON_SINGLE_ITEMS,
+    ITER_OUT_OF_BOUNDS,
+    ITER_OVEREAGER_CLONED,
+    ITER_SKIP_NEXT,
+    ITER_SKIP_ZERO,
+    ITER_WITH_DRAIN,
+    JOIN_ABSOLUTE_PATHS,
+    LINES_FILTER_MAP_OK,
+    MANUAL_CONTAINS,
+    MANUAL_C_STR_LITERALS,
+    MANUAL_FILTER_MAP,
+    MANUAL_FIND_MAP,
+    MANUAL_INSPECT,
+    MANUAL_IS_VARIANT_AND,
+    MANUAL_NEXT_BACK,
+    MANUAL_OK_OR,
+    MANUAL_REPEAT_N,
+    MANUAL_SATURATING_ARITHMETIC,
+    MANUAL_SPLIT_ONCE,
+    MANUAL_STR_REPEAT,
+    MANUAL_TRY_FOLD,
+    MAP_ALL_ANY_IDENTITY,
+    MAP_CLONE,
+    MAP_COLLECT_RESULT_UNIT,
+    MAP_ERR_IGNORE,
+    MAP_FLATTEN,
+    MAP_IDENTITY,
+    MAP_UNWRAP_OR,
+    MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
+    MUT_MUTEX_LOCK,
+    NAIVE_BYTECOUNT,
+    NEEDLESS_AS_BYTES,
+    NEEDLESS_CHARACTER_ITERATION,
+    NEEDLESS_COLLECT,
+    NEEDLESS_OPTION_AS_DEREF,
+    NEEDLESS_OPTION_TAKE,
+    NEEDLESS_SPLITN,
+    NEW_RET_NO_SELF,
+    NONSENSICAL_OPEN_OPTIONS,
+    NO_EFFECT_REPLACE,
+    OBFUSCATED_IF_ELSE,
+    OK_EXPECT,
+    OPTION_AS_REF_CLONED,
+    OPTION_AS_REF_DEREF,
+    OPTION_FILTER_MAP,
+    OPTION_MAP_OR_NONE,
+    OR_FUN_CALL,
+    OR_THEN_UNWRAP,
+    PATH_BUF_PUSH_OVERWRITE,
+    PATH_ENDS_WITH_EXT,
+    PTR_OFFSET_BY_LITERAL,
+    PTR_OFFSET_WITH_CAST,
+    RANGE_ZIP_WITH_LEN,
+    READONLY_WRITE_LOCK,
+    READ_LINE_WITHOUT_TRIM,
+    REDUNDANT_AS_STR,
+    REDUNDANT_ITER_CLONED,
+    REPEAT_ONCE,
+    RESULT_FILTER_MAP,
+    RESULT_MAP_OR_INTO_OPTION,
+    RETURN_AND_THEN,
+    SEARCH_IS_SOME,
+    SEEK_FROM_CURRENT,
+    SEEK_TO_START_INSTEAD_OF_REWIND,
+    SHOULD_IMPLEMENT_TRAIT,
+    SINGLE_CHAR_ADD_STR,
+    SKIP_WHILE_NEXT,
+    SLICED_STRING_AS_BYTES,
+    STABLE_SORT_PRIMITIVE,
+    STRING_EXTEND_CHARS,
+    STRING_LIT_CHARS_ANY,
+    STR_SPLIT_AT_NEWLINE,
+    SUSPICIOUS_COMMAND_ARG_SPACE,
+    SUSPICIOUS_MAP,
+    SUSPICIOUS_OPEN_OPTIONS,
+    SUSPICIOUS_SPLITN,
+    SUSPICIOUS_TO_OWNED,
+    SWAP_WITH_TEMPORARY,
+    TYPE_ID_ON_BOX,
+    UNBUFFERED_BYTES,
+    UNINIT_ASSUMED_INIT,
+    UNIT_HASH,
+    UNNECESSARY_FALLIBLE_CONVERSIONS,
+    UNNECESSARY_FILTER_MAP,
+    UNNECESSARY_FIND_MAP,
+    UNNECESSARY_FIRST_THEN_CHECK,
+    UNNECESSARY_FOLD,
+    UNNECESSARY_GET_THEN_CHECK,
+    UNNECESSARY_JOIN,
+    UNNECESSARY_LAZY_EVALUATIONS,
+    UNNECESSARY_LITERAL_UNWRAP,
+    UNNECESSARY_MAP_OR,
+    UNNECESSARY_MIN_OR_MAX,
+    UNNECESSARY_OPTION_MAP_OR_ELSE,
+    UNNECESSARY_RESULT_MAP_OR_ELSE,
+    UNNECESSARY_SORT_BY,
+    UNNECESSARY_TO_OWNED,
+    UNWRAP_OR_DEFAULT,
+    UNWRAP_USED,
+    USELESS_ASREF,
+    USELESS_NONZERO_NEW_UNCHECKED,
+    VEC_RESIZE_TO_ZERO,
+    VERBOSE_FILE_READS,
+    WAKER_CLONE_WAKE,
+    WRONG_SELF_CONVENTION,
+    ZST_OFFSET,
+]);
 
 #[expect(clippy::struct_excessive_bools)]
 pub struct Methods {
@@ -4782,162 +4938,6 @@ impl Methods {
     }
 }
 
-impl_lint_pass!(Methods => [
-    UNWRAP_USED,
-    EXPECT_USED,
-    SHOULD_IMPLEMENT_TRAIT,
-    WRONG_SELF_CONVENTION,
-    OK_EXPECT,
-    UNWRAP_OR_DEFAULT,
-    MAP_UNWRAP_OR,
-    RESULT_MAP_OR_INTO_OPTION,
-    OPTION_MAP_OR_NONE,
-    BIND_INSTEAD_OF_MAP,
-    OR_FUN_CALL,
-    OR_THEN_UNWRAP,
-    EXPECT_FUN_CALL,
-    CHARS_NEXT_CMP,
-    CHARS_LAST_CMP,
-    CLONE_ON_COPY,
-    CLONE_ON_REF_PTR,
-    COLLAPSIBLE_STR_REPLACE,
-    CONST_IS_EMPTY,
-    ITER_OVEREAGER_CLONED,
-    CLONED_INSTEAD_OF_COPIED,
-    FLAT_MAP_OPTION,
-    INEFFICIENT_TO_STRING,
-    NEW_RET_NO_SELF,
-    SINGLE_CHAR_ADD_STR,
-    SEARCH_IS_SOME,
-    FILTER_NEXT,
-    SKIP_WHILE_NEXT,
-    FILTER_MAP_IDENTITY,
-    MAP_IDENTITY,
-    MANUAL_FILTER_MAP,
-    MANUAL_FIND_MAP,
-    OPTION_FILTER_MAP,
-    FILTER_MAP_NEXT,
-    FLAT_MAP_IDENTITY,
-    MAP_FLATTEN,
-    ITERATOR_STEP_BY_ZERO,
-    ITER_NEXT_SLICE,
-    ITER_COUNT,
-    ITER_NTH,
-    ITER_NTH_ZERO,
-    BYTES_NTH,
-    ITER_SKIP_NEXT,
-    GET_UNWRAP,
-    GET_LAST_WITH_LEN,
-    STRING_EXTEND_CHARS,
-    ITER_CLONED_COLLECT,
-    ITER_WITH_DRAIN,
-    TYPE_ID_ON_BOX,
-    USELESS_ASREF,
-    UNNECESSARY_FOLD,
-    UNNECESSARY_FILTER_MAP,
-    UNNECESSARY_FIND_MAP,
-    INTO_ITER_ON_REF,
-    SUSPICIOUS_MAP,
-    UNINIT_ASSUMED_INIT,
-    MANUAL_SATURATING_ARITHMETIC,
-    ZST_OFFSET,
-    PTR_OFFSET_BY_LITERAL,
-    PTR_OFFSET_WITH_CAST,
-    FILETYPE_IS_FILE,
-    OPTION_AS_REF_DEREF,
-    UNNECESSARY_LAZY_EVALUATIONS,
-    MAP_COLLECT_RESULT_UNIT,
-    FROM_ITER_INSTEAD_OF_COLLECT,
-    INSPECT_FOR_EACH,
-    IMPLICIT_CLONE,
-    SUSPICIOUS_TO_OWNED,
-    SUSPICIOUS_SPLITN,
-    MANUAL_STR_REPEAT,
-    EXTEND_WITH_DRAIN,
-    MANUAL_SPLIT_ONCE,
-    NEEDLESS_SPLITN,
-    UNNECESSARY_TO_OWNED,
-    UNNECESSARY_JOIN,
-    ERR_EXPECT,
-    NEEDLESS_OPTION_AS_DEREF,
-    IS_DIGIT_ASCII_RADIX,
-    NEEDLESS_OPTION_TAKE,
-    NO_EFFECT_REPLACE,
-    OBFUSCATED_IF_ELSE,
-    ITER_ON_SINGLE_ITEMS,
-    ITER_ON_EMPTY_COLLECTIONS,
-    NAIVE_BYTECOUNT,
-    BYTES_COUNT_TO_LEN,
-    CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-    GET_FIRST,
-    MANUAL_OK_OR,
-    MAP_CLONE,
-    MAP_ERR_IGNORE,
-    MUT_MUTEX_LOCK,
-    NONSENSICAL_OPEN_OPTIONS,
-    SUSPICIOUS_OPEN_OPTIONS,
-    PATH_BUF_PUSH_OVERWRITE,
-    RANGE_ZIP_WITH_LEN,
-    REPEAT_ONCE,
-    STABLE_SORT_PRIMITIVE,
-    UNIT_HASH,
-    READ_LINE_WITHOUT_TRIM,
-    UNNECESSARY_SORT_BY,
-    VEC_RESIZE_TO_ZERO,
-    VERBOSE_FILE_READS,
-    ITER_KV_MAP,
-    SEEK_FROM_CURRENT,
-    SEEK_TO_START_INSTEAD_OF_REWIND,
-    NEEDLESS_COLLECT,
-    SUSPICIOUS_COMMAND_ARG_SPACE,
-    CLEAR_WITH_DRAIN,
-    MANUAL_NEXT_BACK,
-    UNNECESSARY_LITERAL_UNWRAP,
-    DRAIN_COLLECT,
-    MANUAL_TRY_FOLD,
-    FORMAT_COLLECT,
-    STRING_LIT_CHARS_ANY,
-    ITER_SKIP_ZERO,
-    FILTER_MAP_BOOL_THEN,
-    READONLY_WRITE_LOCK,
-    ITER_OUT_OF_BOUNDS,
-    PATH_ENDS_WITH_EXT,
-    REDUNDANT_AS_STR,
-    WAKER_CLONE_WAKE,
-    UNNECESSARY_FALLIBLE_CONVERSIONS,
-    JOIN_ABSOLUTE_PATHS,
-    RESULT_FILTER_MAP,
-    ITER_FILTER_IS_SOME,
-    ITER_FILTER_IS_OK,
-    MANUAL_IS_VARIANT_AND,
-    STR_SPLIT_AT_NEWLINE,
-    OPTION_AS_REF_CLONED,
-    UNNECESSARY_RESULT_MAP_OR_ELSE,
-    MANUAL_C_STR_LITERALS,
-    UNNECESSARY_GET_THEN_CHECK,
-    UNNECESSARY_FIRST_THEN_CHECK,
-    NEEDLESS_CHARACTER_ITERATION,
-    MANUAL_INSPECT,
-    UNNECESSARY_MIN_OR_MAX,
-    NEEDLESS_AS_BYTES,
-    MAP_ALL_ANY_IDENTITY,
-    MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
-    UNNECESSARY_MAP_OR,
-    DOUBLE_ENDED_ITERATOR_LAST,
-    USELESS_NONZERO_NEW_UNCHECKED,
-    MANUAL_REPEAT_N,
-    SLICED_STRING_AS_BYTES,
-    RETURN_AND_THEN,
-    UNBUFFERED_BYTES,
-    MANUAL_CONTAINS,
-    IO_OTHER_ERROR,
-    SWAP_WITH_TEMPORARY,
-    IP_CONSTANT,
-    REDUNDANT_ITER_CLONED,
-    UNNECESSARY_OPTION_MAP_OR_ELSE,
-    LINES_FILTER_MAP_OK,
-]);
-
 /// Extracts a method call name, args, and `Span` of the method name.
 /// This ensures that neither the receiver nor any of the arguments
 /// come from expansion.
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index 1ceee836732a..2bb574ac113c 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -45,6 +45,7 @@ declare_clippy_lint! {
     restriction,
     "disallows idents that are too short"
 }
+
 impl_lint_pass!(MinIdentChars => [MIN_IDENT_CHARS]);
 
 pub struct MinIdentChars {
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 19e9910dfe9d..c77b87268910 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -7,6 +7,27 @@ use rustc_hir::{BinOpKind, Expr, ExprKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::declare_lint_pass;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the use of short circuit boolean conditions as
+    /// a
+    /// statement.
+    ///
+    /// ### Why is this bad?
+    /// Using a short circuit boolean condition as a statement
+    /// may hide the fact that the second part is executed or not depending on the
+    /// outcome of the first part.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// f() && g(); // We should write `if f() { g(); }`.
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub SHORT_CIRCUIT_STATEMENT,
+    complexity,
+    "using a short circuit boolean condition as a statement"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the use of bindings with a single leading
@@ -72,31 +93,10 @@ declare_clippy_lint! {
     "using a item which is prefixed with an underscore"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the use of short circuit boolean conditions as
-    /// a
-    /// statement.
-    ///
-    /// ### Why is this bad?
-    /// Using a short circuit boolean condition as a statement
-    /// may hide the fact that the second part is executed or not depending on the
-    /// outcome of the first part.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// f() && g(); // We should write `if f() { g(); }`.
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub SHORT_CIRCUIT_STATEMENT,
-    complexity,
-    "using a short circuit boolean condition as a statement"
-}
-
 declare_lint_pass!(LintPass => [
+    SHORT_CIRCUIT_STATEMENT,
     USED_UNDERSCORE_BINDING,
     USED_UNDERSCORE_ITEMS,
-    SHORT_CIRCUIT_STATEMENT,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for LintPass {
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index f988323a8c13..604b946d91a7 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -16,45 +16,24 @@ use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for structure field patterns bound to wildcards.
+    /// Warns if a generic shadows a built-in type.
     ///
-    /// ### Why restrict this?
-    /// Using `..` instead is shorter and leaves the focus on
-    /// the fields that are actually bound.
+    /// ### Why is this bad?
+    /// This gives surprising type errors.
     ///
     /// ### Example
-    /// ```no_run
-    /// # struct Foo {
-    /// #     a: i32,
-    /// #     b: i32,
-    /// #     c: i32,
-    /// # }
-    /// let f = Foo { a: 0, b: 0, c: 0 };
     ///
-    /// match f {
-    ///     Foo { a: _, b: 0, .. } => {},
-    ///     Foo { a: _, b: _, c: _ } => {},
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # struct Foo {
-    /// #     a: i32,
-    /// #     b: i32,
-    /// #     c: i32,
-    /// # }
-    /// let f = Foo { a: 0, b: 0, c: 0 };
-    ///
-    /// match f {
-    ///     Foo { b: 0, .. } => {},
-    ///     Foo { .. } => {},
+    /// ```ignore
+    /// impl<u32> Foo<u32> {
+    ///     fn impl_func(&self) -> u32 {
+    ///         42
+    ///     }
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub UNNEEDED_FIELD_PATTERN,
-    restriction,
-    "struct fields bound to a wildcard instead of using `..`"
+    pub BUILTIN_TYPE_SHADOW,
+    style,
+    "shadowing a builtin type"
 }
 
 declare_clippy_lint! {
@@ -86,31 +65,63 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns if literal suffixes are not separated by an
-    /// underscore.
-    /// To enforce unseparated literal suffix style,
-    /// see the `separated_literal_suffix` lint.
+    /// Checks for `[all @ ..]` patterns.
     ///
-    /// ### Why restrict this?
-    /// Suffix style should be consistent.
+    /// ### Why is this bad?
+    /// In all cases, `all` works fine and can often make code simpler, as you possibly won't need
+    /// to convert from say a `Vec` to a slice by dereferencing.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// if let [all @ ..] = &*v {
+    ///     // NOTE: Type is a slice here
+    ///     println!("all elements: {all:#?}");
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// if let all = v {
+    ///     // NOTE: Type is a `Vec` here
+    ///     println!("all elements: {all:#?}");
+    /// }
+    /// // or
+    /// println!("all elements: {v:#?}");
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub REDUNDANT_AT_REST_PATTERN,
+    complexity,
+    "checks for `[all @ ..]` where `all` would suffice"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for patterns in the form `name @ _`.
+    ///
+    /// ### Why is this bad?
+    /// It's almost always more readable to just use direct
+    /// bindings.
     ///
     /// ### Example
     /// ```no_run
-    /// # let _ =
-    /// 123832i32
-    /// # ;
+    /// # let v = Some("abc");
+    /// match v {
+    ///     Some(x) => (),
+    ///     y @ _ => (),
+    /// }
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # let _ =
-    /// 123832_i32
-    /// # ;
+    /// # let v = Some("abc");
+    /// match v {
+    ///     Some(x) => (),
+    ///     y => (),
+    /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub UNSEPARATED_LITERAL_SUFFIX,
-    restriction,
-    "literals whose suffix is not separated by an underscore"
+    pub REDUNDANT_PATTERN,
+    style,
+    "using `name @ _` in a pattern"
 }
 
 declare_clippy_lint! {
@@ -143,94 +154,45 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns if an integral constant literal starts with `0`.
+    /// Checks for structure field patterns bound to wildcards.
     ///
-    /// ### Why is this bad?
-    /// In some languages (including the infamous C language
-    /// and most of its
-    /// family), this marks an octal constant. In Rust however, this is a decimal
-    /// constant. This could
-    /// be confusing for both the writer and a reader of the constant.
+    /// ### Why restrict this?
+    /// Using `..` instead is shorter and leaves the focus on
+    /// the fields that are actually bound.
     ///
     /// ### Example
-    ///
-    /// In Rust:
     /// ```no_run
-    /// fn main() {
-    ///     let a = 0123;
-    ///     println!("{}", a);
-    /// }
-    /// ```
-    ///
-    /// prints `123`, while in C:
-    ///
-    /// ```c
-    /// #include <stdio.h>
-    ///
-    /// int main() {
-    ///     int a = 0123;
-    ///     printf("%d\n", a);
-    /// }
-    /// ```
-    ///
-    /// prints `83` (as `83 == 0o123` while `123 == 0o173`).
-    #[clippy::version = "pre 1.29.0"]
-    pub ZERO_PREFIXED_LITERAL,
-    complexity,
-    "integer literals starting with `0`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns if a generic shadows a built-in type.
-    ///
-    /// ### Why is this bad?
-    /// This gives surprising type errors.
-    ///
-    /// ### Example
-    ///
-    /// ```ignore
-    /// impl<u32> Foo<u32> {
-    ///     fn impl_func(&self) -> u32 {
-    ///         42
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub BUILTIN_TYPE_SHADOW,
-    style,
-    "shadowing a builtin type"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for patterns in the form `name @ _`.
-    ///
-    /// ### Why is this bad?
-    /// It's almost always more readable to just use direct
-    /// bindings.
+    /// # struct Foo {
+    /// #     a: i32,
+    /// #     b: i32,
+    /// #     c: i32,
+    /// # }
+    /// let f = Foo { a: 0, b: 0, c: 0 };
     ///
-    /// ### Example
-    /// ```no_run
-    /// # let v = Some("abc");
-    /// match v {
-    ///     Some(x) => (),
-    ///     y @ _ => (),
+    /// match f {
+    ///     Foo { a: _, b: 0, .. } => {},
+    ///     Foo { a: _, b: _, c: _ } => {},
     /// }
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # let v = Some("abc");
-    /// match v {
-    ///     Some(x) => (),
-    ///     y => (),
+    /// # struct Foo {
+    /// #     a: i32,
+    /// #     b: i32,
+    /// #     c: i32,
+    /// # }
+    /// let f = Foo { a: 0, b: 0, c: 0 };
+    ///
+    /// match f {
+    ///     Foo { b: 0, .. } => {},
+    ///     Foo { .. } => {},
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub REDUNDANT_PATTERN,
-    style,
-    "using `name @ _` in a pattern"
+    pub UNNEEDED_FIELD_PATTERN,
+    restriction,
+    "struct fields bound to a wildcard instead of using `..`"
 }
 
 declare_clippy_lint! {
@@ -274,44 +236,82 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `[all @ ..]` patterns.
+    /// Warns if literal suffixes are not separated by an
+    /// underscore.
+    /// To enforce unseparated literal suffix style,
+    /// see the `separated_literal_suffix` lint.
+    ///
+    /// ### Why restrict this?
+    /// Suffix style should be consistent.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let _ =
+    /// 123832i32
+    /// # ;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let _ =
+    /// 123832_i32
+    /// # ;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub UNSEPARATED_LITERAL_SUFFIX,
+    restriction,
+    "literals whose suffix is not separated by an underscore"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns if an integral constant literal starts with `0`.
     ///
     /// ### Why is this bad?
-    /// In all cases, `all` works fine and can often make code simpler, as you possibly won't need
-    /// to convert from say a `Vec` to a slice by dereferencing.
+    /// In some languages (including the infamous C language
+    /// and most of its
+    /// family), this marks an octal constant. In Rust however, this is a decimal
+    /// constant. This could
+    /// be confusing for both the writer and a reader of the constant.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// if let [all @ ..] = &*v {
-    ///     // NOTE: Type is a slice here
-    ///     println!("all elements: {all:#?}");
+    ///
+    /// In Rust:
+    /// ```no_run
+    /// fn main() {
+    ///     let a = 0123;
+    ///     println!("{}", a);
     /// }
     /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// if let all = v {
-    ///     // NOTE: Type is a `Vec` here
-    ///     println!("all elements: {all:#?}");
+    ///
+    /// prints `123`, while in C:
+    ///
+    /// ```c
+    /// #include <stdio.h>
+    ///
+    /// int main() {
+    ///     int a = 0123;
+    ///     printf("%d\n", a);
     /// }
-    /// // or
-    /// println!("all elements: {v:#?}");
     /// ```
-    #[clippy::version = "1.72.0"]
-    pub REDUNDANT_AT_REST_PATTERN,
+    ///
+    /// prints `83` (as `83 == 0o123` while `123 == 0o173`).
+    #[clippy::version = "pre 1.29.0"]
+    pub ZERO_PREFIXED_LITERAL,
     complexity,
-    "checks for `[all @ ..]` where `all` would suffice"
+    "integer literals starting with `0`"
 }
 
 declare_lint_pass!(MiscEarlyLints => [
-    UNNEEDED_FIELD_PATTERN,
-    MIXED_CASE_HEX_LITERALS,
-    UNSEPARATED_LITERAL_SUFFIX,
-    SEPARATED_LITERAL_SUFFIX,
-    ZERO_PREFIXED_LITERAL,
     BUILTIN_TYPE_SHADOW,
+    MIXED_CASE_HEX_LITERALS,
+    REDUNDANT_AT_REST_PATTERN,
     REDUNDANT_PATTERN,
+    SEPARATED_LITERAL_SUFFIX,
+    UNNEEDED_FIELD_PATTERN,
     UNNEEDED_WILDCARD_PATTERN,
-    REDUNDANT_AT_REST_PATTERN,
+    UNSEPARATED_LITERAL_SUFFIX,
+    ZERO_PREFIXED_LITERAL,
 ]);
 
 impl EarlyLintPass for MiscEarlyLints {
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index 394bc4aef1cc..70eab98bd067 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -45,6 +45,7 @@ declare_clippy_lint! {
     pedantic,
     "type parameter positioned inconsistently between type def and impl block"
 }
+
 declare_lint_pass!(TypeParamMismatch => [MISMATCHING_TYPE_PARAM_ORDER]);
 
 impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index 651382fb4bfe..2773f537efc6 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -65,6 +65,7 @@ declare_clippy_lint! {
     restriction,
     "indexing into a slice multiple times without an `assert`"
 }
+
 declare_lint_pass!(MissingAssertsForIndexing => [MISSING_ASSERTS_FOR_INDEXING]);
 
 fn report_lint<F>(cx: &LateContext<'_>, index_spans: Vec<Span>, msg: &'static str, f: F)
diff --git a/clippy_lints/src/missing_const_for_thread_local.rs b/clippy_lints/src/missing_const_for_thread_local.rs
index ea74940828a1..50f393553ebf 100644
--- a/clippy_lints/src/missing_const_for_thread_local.rs
+++ b/clippy_lints/src/missing_const_for_thread_local.rs
@@ -43,6 +43,8 @@ declare_clippy_lint! {
     "suggest using `const` in `thread_local!` macro"
 }
 
+impl_lint_pass!(MissingConstForThreadLocal => [MISSING_CONST_FOR_THREAD_LOCAL]);
+
 pub struct MissingConstForThreadLocal {
     msrv: Msrv,
 }
@@ -53,8 +55,6 @@ impl MissingConstForThreadLocal {
     }
 }
 
-impl_lint_pass!(MissingConstForThreadLocal => [MISSING_CONST_FOR_THREAD_LOCAL]);
-
 #[inline]
 fn is_thread_local_initializer(
     cx: &LateContext<'_>,
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 375b275cd113..89a61298bf19 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -29,6 +29,8 @@ declare_clippy_lint! {
     "detects missing documentation for private members"
 }
 
+impl_lint_pass!(MissingDoc => [MISSING_DOCS_IN_PRIVATE_ITEMS]);
+
 pub struct MissingDoc {
     /// Whether to **only** check for missing documentation in items visible within the current
     /// crate. For example, `pub(crate)` items.
@@ -99,8 +101,6 @@ impl MissingDoc {
     }
 }
 
-impl_lint_pass!(MissingDoc => [MISSING_DOCS_IN_PRIVATE_ITEMS]);
-
 impl<'tcx> LateLintPass<'tcx> for MissingDoc {
     fn check_attributes(&mut self, _: &LateContext<'tcx>, attrs: &'tcx [Attribute]) {
         self.attr_depth += 1;
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 1f9652a2bd38..7dbe39bb099d 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -46,6 +46,8 @@ declare_clippy_lint! {
     "enforce import renames"
 }
 
+impl_lint_pass!(ImportRename => [MISSING_ENFORCED_IMPORT_RENAMES]);
+
 pub struct ImportRename {
     renames: DefIdMap<Symbol>,
 }
@@ -67,8 +69,6 @@ impl ImportRename {
     }
 }
 
-impl_lint_pass!(ImportRename => [MISSING_ENFORCED_IMPORT_RENAMES]);
-
 impl LateLintPass<'_> for ImportRename {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if let ItemKind::Use(path, UseKind::Single(_)) = &item.kind {
diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
index a26f24d15247..332c19e140b3 100644
--- a/clippy_lints/src/missing_fields_in_debug.rs
+++ b/clippy_lints/src/missing_fields_in_debug.rs
@@ -76,6 +76,7 @@ declare_clippy_lint! {
     pedantic,
     "missing fields in manual `Debug` implementation"
 }
+
 declare_lint_pass!(MissingFieldsInDebug => [MISSING_FIELDS_IN_DEBUG]);
 
 fn report_lints(cx: &LateContext<'_>, span: Span, span_notes: Vec<(Span, &'static str)>) {
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index c308f2a34585..e55c68c81798 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -65,6 +65,8 @@ declare_clippy_lint! {
     "detects missing `#[inline]` attribute for public callables (functions, trait methods, methods...)"
 }
 
+declare_lint_pass!(MissingInline => [MISSING_INLINE_IN_PUBLIC_ITEMS]);
+
 fn check_missing_inline_attrs(
     cx: &LateContext<'_>,
     attrs: &[Attribute],
@@ -82,8 +84,6 @@ fn check_missing_inline_attrs(
     }
 }
 
-declare_lint_pass!(MissingInline => [MISSING_INLINE_IN_PUBLIC_ITEMS]);
-
 impl<'tcx> LateLintPass<'tcx> for MissingInline {
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx hir::Item<'_>) {
         if it.span.in_external_macro(cx.sess().source_map()) {
diff --git a/clippy_lints/src/missing_trait_methods.rs b/clippy_lints/src/missing_trait_methods.rs
index 7a791f949943..332d31feeecf 100644
--- a/clippy_lints/src/missing_trait_methods.rs
+++ b/clippy_lints/src/missing_trait_methods.rs
@@ -55,6 +55,7 @@ declare_clippy_lint! {
     restriction,
     "trait implementation uses default provided method"
 }
+
 declare_lint_pass!(MissingTraitMethods => [MISSING_TRAIT_METHODS]);
 
 impl<'tcx> LateLintPass<'tcx> for MissingTraitMethods {
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 53f97abe0b44..99561e60f725 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -8,6 +8,34 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for diverging calls that are not match arms or
+    /// statements.
+    ///
+    /// ### Why is this bad?
+    /// It is often confusing to read. In addition, the
+    /// sub-expression evaluation order for Rust is not well documented.
+    ///
+    /// ### Known problems
+    /// Someone might want to use `some_bool || panic!()` as a
+    /// shorthand.
+    ///
+    /// ### Example
+    /// ```rust,no_run
+    /// # fn b() -> bool { true }
+    /// # fn c() -> bool { true }
+    /// let a = b() || panic!() || c();
+    /// // `c()` is dead, `panic!()` is only called if `b()` returns `false`
+    /// let x = (a, b, c, panic!());
+    /// // can simply be replaced by `panic!()`
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DIVERGING_SUB_EXPRESSION,
+    complexity,
+    "whether an expression contains a diverging sub expression"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for a read and a write to the same variable where
@@ -51,35 +79,10 @@ declare_clippy_lint! {
     "whether a variable read occurs before a write depends on sub-expression evaluation order"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for diverging calls that are not match arms or
-    /// statements.
-    ///
-    /// ### Why is this bad?
-    /// It is often confusing to read. In addition, the
-    /// sub-expression evaluation order for Rust is not well documented.
-    ///
-    /// ### Known problems
-    /// Someone might want to use `some_bool || panic!()` as a
-    /// shorthand.
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// # fn b() -> bool { true }
-    /// # fn c() -> bool { true }
-    /// let a = b() || panic!() || c();
-    /// // `c()` is dead, `panic!()` is only called if `b()` returns `false`
-    /// let x = (a, b, c, panic!());
-    /// // can simply be replaced by `panic!()`
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DIVERGING_SUB_EXPRESSION,
-    complexity,
-    "whether an expression contains a diverging sub expression"
-}
-
-declare_lint_pass!(EvalOrderDependence => [MIXED_READ_WRITE_IN_EXPRESSION, DIVERGING_SUB_EXPRESSION]);
+declare_lint_pass!(EvalOrderDependence => [
+    DIVERGING_SUB_EXPRESSION,
+    MIXED_READ_WRITE_IN_EXPRESSION,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index ebf7ccfd5ba7..7e96507a27b1 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -72,6 +72,7 @@ declare_clippy_lint! {
     restriction,
     "more than one unsafe operation per `unsafe` block"
 }
+
 declare_lint_pass!(MultipleUnsafeOpsPerBlock => [MULTIPLE_UNSAFE_OPS_PER_BLOCK]);
 
 impl<'tcx> LateLintPass<'tcx> for MultipleUnsafeOpsPerBlock {
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 98a9a98d281a..aa43eb0f58e7 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -68,12 +68,12 @@ declare_clippy_lint! {
     "Check for mutable `Map`/`Set` key type"
 }
 
+impl_lint_pass!(MutableKeyType<'_> => [MUTABLE_KEY_TYPE]);
+
 pub struct MutableKeyType<'tcx> {
     interior_mut: InteriorMut<'tcx>,
 }
 
-impl_lint_pass!(MutableKeyType<'_> => [ MUTABLE_KEY_TYPE ]);
-
 impl<'tcx> LateLintPass<'tcx> for MutableKeyType<'tcx> {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
         if let hir::ItemKind::Fn { ref sig, .. } = item.kind {
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 6b5db9dcf3e2..387b6f8bf223 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -80,6 +80,7 @@ declare_clippy_lint! {
     complexity,
     "setting the same boolean variable in both branches of an if-statement"
 }
+
 declare_lint_pass!(NeedlessBool => [NEEDLESS_BOOL, NEEDLESS_BOOL_ASSIGN]);
 
 fn condition_needs_parentheses(e: &Expr<'_>) -> bool {
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index 25fcc7ee568e..a4bc33b70c21 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -57,6 +57,10 @@ declare_clippy_lint! {
     "taking a reference that is going to be automatically dereferenced"
 }
 
+impl_lint_pass!(NeedlessBorrowsForGenericArgs<'_> => [
+    NEEDLESS_BORROWS_FOR_GENERIC_ARGS,
+]);
+
 pub struct NeedlessBorrowsForGenericArgs<'tcx> {
     /// Stack of (body owner, `PossibleBorrowerMap`) pairs. Used by
     /// [`needless_borrow_count`] to determine when a borrowed expression can instead
@@ -66,8 +70,6 @@ pub struct NeedlessBorrowsForGenericArgs<'tcx> {
     // `IntoIterator` for arrays requires Rust 1.53.
     msrv: Msrv,
 }
-impl_lint_pass!(NeedlessBorrowsForGenericArgs<'_> => [NEEDLESS_BORROWS_FOR_GENERIC_ARGS]);
-
 impl NeedlessBorrowsForGenericArgs<'_> {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/needless_else.rs b/clippy_lints/src/needless_else.rs
index f8bb72a16db2..807c4cf5da8e 100644
--- a/clippy_lints/src/needless_else.rs
+++ b/clippy_lints/src/needless_else.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     style,
     "empty else branch"
 }
+
 declare_lint_pass!(NeedlessElse => [NEEDLESS_ELSE]);
 
 impl EarlyLintPass for NeedlessElse {
diff --git a/clippy_lints/src/needless_ifs.rs b/clippy_lints/src/needless_ifs.rs
index 8ec7e47ccc5b..ad1da9441dac 100644
--- a/clippy_lints/src/needless_ifs.rs
+++ b/clippy_lints/src/needless_ifs.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     complexity,
     "checks for empty if branches"
 }
+
 declare_lint_pass!(NeedlessIfs => [NEEDLESS_IFS]);
 
 impl LateLintPass<'_> for NeedlessIfs {
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 464a91959a8e..bc4f6ca40171 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -60,6 +60,7 @@ declare_clippy_lint! {
     style,
     "late initializations that can be replaced by a `let` statement with an initializer"
 }
+
 declare_lint_pass!(NeedlessLateInit => [NEEDLESS_LATE_INIT]);
 
 fn contains_assign_expr<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) -> bool {
diff --git a/clippy_lints/src/needless_maybe_sized.rs b/clippy_lints/src/needless_maybe_sized.rs
index e7ae54e0d0e1..d718751e3428 100644
--- a/clippy_lints/src/needless_maybe_sized.rs
+++ b/clippy_lints/src/needless_maybe_sized.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     suspicious,
     "a `?Sized` bound that is unusable due to a `Sized` requirement"
 }
+
 declare_lint_pass!(NeedlessMaybeSized => [NEEDLESS_MAYBE_SIZED]);
 
 #[expect(clippy::struct_field_names)]
diff --git a/clippy_lints/src/needless_parens_on_range_literals.rs b/clippy_lints/src/needless_parens_on_range_literals.rs
index f270ba7277cb..0c23bd6b1f96 100644
--- a/clippy_lints/src/needless_parens_on_range_literals.rs
+++ b/clippy_lints/src/needless_parens_on_range_literals.rs
@@ -38,7 +38,9 @@ declare_clippy_lint! {
   "needless parenthesis on range literals can be removed"
 }
 
-declare_lint_pass!(NeedlessParensOnRangeLiterals => [NEEDLESS_PARENS_ON_RANGE_LITERALS]);
+declare_lint_pass!(NeedlessParensOnRangeLiterals => [
+    NEEDLESS_PARENS_ON_RANGE_LITERALS,
+]);
 
 fn snippet_enclosed_in_parenthesis(snippet: &str) -> bool {
     snippet.starts_with('(') && snippet.ends_with(')')
diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index f3e42b1c58f8..2b1f7574a83a 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -51,6 +51,8 @@ declare_clippy_lint! {
     "using a `&mut` argument when it's not mutated"
 }
 
+impl_lint_pass!(NeedlessPassByRefMut<'_> => [NEEDLESS_PASS_BY_REF_MUT]);
+
 pub struct NeedlessPassByRefMut<'tcx> {
     avoid_breaking_exported_api: bool,
     used_fn_def_ids: FxHashSet<LocalDefId>,
@@ -67,8 +69,6 @@ impl NeedlessPassByRefMut<'_> {
     }
 }
 
-impl_lint_pass!(NeedlessPassByRefMut<'_> => [NEEDLESS_PASS_BY_REF_MUT]);
-
 fn should_skip<'tcx>(
     cx: &LateContext<'tcx>,
     input: rustc_hir::Ty<'tcx>,
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index e151c06c6c20..ce8ce2aa900a 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -50,13 +50,13 @@ declare_clippy_lint! {
     "`pub fn new() -> Self` method without `Default` implementation"
 }
 
+impl_lint_pass!(NewWithoutDefault => [NEW_WITHOUT_DEFAULT]);
+
 #[derive(Clone, Default)]
 pub struct NewWithoutDefault {
     impling_types: Option<HirIdSet>,
 }
 
-impl_lint_pass!(NewWithoutDefault => [NEW_WITHOUT_DEFAULT]);
-
 impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
     #[expect(clippy::too_many_lines)]
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index fdb8e1b475c1..d317912c0a9c 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -73,14 +73,18 @@ declare_clippy_lint! {
     "outer expressions with no effect"
 }
 
+impl_lint_pass!(NoEffect => [
+    NO_EFFECT,
+    NO_EFFECT_UNDERSCORE_BINDING,
+    UNNECESSARY_OPERATION,
+]);
+
 #[derive(Default)]
 pub struct NoEffect {
     underscore_bindings: HirIdMap<Span>,
     local_bindings: Vec<Vec<HirId>>,
 }
 
-impl_lint_pass!(NoEffect => [NO_EFFECT, UNNECESSARY_OPERATION, NO_EFFECT_UNDERSCORE_BINDING]);
-
 impl<'tcx> LateLintPass<'tcx> for NoEffect {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if self.check_no_effect(cx, stmt) {
diff --git a/clippy_lints/src/no_mangle_with_rust_abi.rs b/clippy_lints/src/no_mangle_with_rust_abi.rs
index daa2c2877944..760a5a920542 100644
--- a/clippy_lints/src/no_mangle_with_rust_abi.rs
+++ b/clippy_lints/src/no_mangle_with_rust_abi.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     pedantic,
     "convert Rust ABI functions to C ABI"
 }
+
 declare_lint_pass!(NoMangleWithRustAbi => [NO_MANGLE_WITH_RUST_ABI]);
 
 impl<'tcx> LateLintPass<'tcx> for NoMangleWithRustAbi {
diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index e66c088617cb..46d1be80b50a 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -51,6 +51,7 @@ declare_clippy_lint! {
     suspicious,
     "non-canonical implementation of `Clone` on a `Copy` type"
 }
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for non-canonical implementations of `PartialOrd` when `Ord` is already implemented.
@@ -108,7 +109,11 @@ declare_clippy_lint! {
     suspicious,
     "non-canonical implementation of `PartialOrd` on an `Ord` type"
 }
-impl_lint_pass!(NonCanonicalImpls => [NON_CANONICAL_CLONE_IMPL, NON_CANONICAL_PARTIAL_ORD_IMPL]);
+
+impl_lint_pass!(NonCanonicalImpls => [
+    NON_CANONICAL_CLONE_IMPL,
+    NON_CANONICAL_PARTIAL_ORD_IMPL,
+]);
 
 #[expect(
     clippy::struct_field_names,
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index e09fc0a76366..24e4661c1f17 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -44,7 +44,7 @@ use std::collections::hash_map::Entry;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the declaration of named constant which contain interior mutability.
+    /// Checks for a borrow of a named constant with interior mutability.
     ///
     /// ### Why is this bad?
     /// Named constants are copied at every use site which means any change to their value
@@ -54,19 +54,25 @@ declare_clippy_lint! {
     /// use core::sync::atomic::{AtomicUsize, Ordering};
     /// const ATOMIC: AtomicUsize = AtomicUsize::new(0);
     /// fn add_one() -> usize {
-    ///     // This will always return `0` since `ATOMIC` is copied before it's used.
+    ///     // This will always return `0` since `ATOMIC` is copied before it's borrowed
+    ///     // for use by `fetch_add`.
     ///     ATOMIC.fetch_add(1, Ordering::AcqRel)
     /// }
     /// ```
     ///
-    /// If shared modification of the value is desired, a `static` item is needed instead.
-    /// If that is not desired, a `const fn` constructor should be used to make it obvious
-    /// at the use site that a new value is created.
-    ///
     /// ### Known problems
-    /// Prior to `const fn` stabilization this was the only way to provide a value which
-    /// could initialize a `static` item (e.g. the `std::sync::ONCE_INIT` constant). In
-    /// this case the use of `const` is required and this lint should be suppressed.
+    /// This lint does not, and cannot in general, determine if the borrow of the constant
+    /// is used in a way which causes a mutation. e.g.
+    ///
+    /// ```rust
+    /// use core::cell::Cell;
+    /// const CELL: Cell<usize> = Cell::new(0);
+    /// fn get_cell() -> Cell<usize> {
+    ///     // This is fine. It borrows a copy of `CELL`, but never mutates it through the
+    ///     // borrow.
+    ///     CELL.clone()
+    /// }
+    /// ```
     ///
     /// There also exists types which contain private fields with interior mutability, but
     /// no way to both create a value as a constant and modify any mutable field using the
@@ -78,28 +84,30 @@ declare_clippy_lint! {
     /// ### Example
     /// ```no_run
     /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
-    ///
     /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
+    ///
     /// CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged
     /// assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
-    /// static STATIC_ATOM: AtomicUsize = AtomicUsize::new(15);
+    /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+    /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
+    ///
+    /// static STATIC_ATOM: AtomicUsize = CONST_ATOM;
     /// STATIC_ATOM.store(9, SeqCst);
     /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub DECLARE_INTERIOR_MUTABLE_CONST,
-    suspicious,
-    "declaring `const` with interior mutability"
+    pub BORROW_INTERIOR_MUTABLE_CONST,
+    style,
+    "referencing `const` with interior mutability"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for a borrow of a named constant with interior mutability.
+    /// Checks for the declaration of named constant which contain interior mutability.
     ///
     /// ### Why is this bad?
     /// Named constants are copied at every use site which means any change to their value
@@ -109,25 +117,19 @@ declare_clippy_lint! {
     /// use core::sync::atomic::{AtomicUsize, Ordering};
     /// const ATOMIC: AtomicUsize = AtomicUsize::new(0);
     /// fn add_one() -> usize {
-    ///     // This will always return `0` since `ATOMIC` is copied before it's borrowed
-    ///     // for use by `fetch_add`.
+    ///     // This will always return `0` since `ATOMIC` is copied before it's used.
     ///     ATOMIC.fetch_add(1, Ordering::AcqRel)
     /// }
     /// ```
     ///
-    /// ### Known problems
-    /// This lint does not, and cannot in general, determine if the borrow of the constant
-    /// is used in a way which causes a mutation. e.g.
+    /// If shared modification of the value is desired, a `static` item is needed instead.
+    /// If that is not desired, a `const fn` constructor should be used to make it obvious
+    /// at the use site that a new value is created.
     ///
-    /// ```rust
-    /// use core::cell::Cell;
-    /// const CELL: Cell<usize> = Cell::new(0);
-    /// fn get_cell() -> Cell<usize> {
-    ///     // This is fine. It borrows a copy of `CELL`, but never mutates it through the
-    ///     // borrow.
-    ///     CELL.clone()
-    /// }
-    /// ```
+    /// ### Known problems
+    /// Prior to `const fn` stabilization this was the only way to provide a value which
+    /// could initialize a `static` item (e.g. the `std::sync::ONCE_INIT` constant). In
+    /// this case the use of `const` is required and this lint should be suppressed.
     ///
     /// There also exists types which contain private fields with interior mutability, but
     /// no way to both create a value as a constant and modify any mutable field using the
@@ -139,27 +141,30 @@ declare_clippy_lint! {
     /// ### Example
     /// ```no_run
     /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
-    /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
     ///
+    /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
     /// CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged
     /// assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
-    /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
-    ///
-    /// static STATIC_ATOM: AtomicUsize = CONST_ATOM;
+    /// # use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+    /// static STATIC_ATOM: AtomicUsize = AtomicUsize::new(15);
     /// STATIC_ATOM.store(9, SeqCst);
     /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub BORROW_INTERIOR_MUTABLE_CONST,
-    style,
-    "referencing `const` with interior mutability"
+    pub DECLARE_INTERIOR_MUTABLE_CONST,
+    suspicious,
+    "declaring `const` with interior mutability"
 }
 
+impl_lint_pass!(NonCopyConst<'_> => [
+    BORROW_INTERIOR_MUTABLE_CONST,
+    DECLARE_INTERIOR_MUTABLE_CONST,
+]);
+
 #[derive(Clone, Copy)]
 enum IsFreeze {
     /// The type and all possible values are `Freeze`
@@ -257,8 +262,6 @@ pub struct NonCopyConst<'tcx> {
     freeze_tys: FxHashMap<Ty<'tcx>, IsFreeze>,
 }
 
-impl_lint_pass!(NonCopyConst<'_> => [DECLARE_INTERIOR_MUTABLE_CONST, BORROW_INTERIOR_MUTABLE_CONST]);
-
 impl<'tcx> NonCopyConst<'tcx> {
     pub fn new(tcx: TyCtxt<'tcx>, conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 1961ac1516da..72542d4845b3 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -12,25 +12,23 @@ use std::cmp::Ordering;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for names that are very similar and thus confusing.
-    ///
-    /// Note: this lint looks for similar names throughout each
-    /// scope. To allow it, you need to allow it on the scope
-    /// level, not on the name that is reported.
+    /// Checks if you have variables whose name consists of just
+    /// underscores and digits.
     ///
     /// ### Why is this bad?
-    /// It's hard to distinguish between names that differ only
-    /// by a single character.
+    /// It's hard to memorize what a variable means without a
+    /// descriptive name.
     ///
     /// ### Example
-    /// ```ignore
-    /// let checked_exp = something;
-    /// let checked_expr = something_else;
+    /// ```no_run
+    /// let _1 = 1;
+    /// let ___1 = 1;
+    /// let __1___2 = 11;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub SIMILAR_NAMES,
-    pedantic,
-    "similarly named items and bindings"
+    pub JUST_UNDERSCORES_AND_DIGITS,
+    style,
+    "unclear name"
 }
 
 declare_clippy_lint! {
@@ -54,31 +52,37 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks if you have variables whose name consists of just
-    /// underscores and digits.
+    /// Checks for names that are very similar and thus confusing.
+    ///
+    /// Note: this lint looks for similar names throughout each
+    /// scope. To allow it, you need to allow it on the scope
+    /// level, not on the name that is reported.
     ///
     /// ### Why is this bad?
-    /// It's hard to memorize what a variable means without a
-    /// descriptive name.
+    /// It's hard to distinguish between names that differ only
+    /// by a single character.
     ///
     /// ### Example
-    /// ```no_run
-    /// let _1 = 1;
-    /// let ___1 = 1;
-    /// let __1___2 = 11;
+    /// ```ignore
+    /// let checked_exp = something;
+    /// let checked_expr = something_else;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub JUST_UNDERSCORES_AND_DIGITS,
-    style,
-    "unclear name"
+    pub SIMILAR_NAMES,
+    pedantic,
+    "similarly named items and bindings"
 }
 
+impl_lint_pass!(NonExpressiveNames => [
+    JUST_UNDERSCORES_AND_DIGITS,
+    MANY_SINGLE_CHAR_NAMES,
+    SIMILAR_NAMES,
+]);
+
 pub struct NonExpressiveNames {
     pub single_char_binding_names_threshold: u64,
 }
 
-impl_lint_pass!(NonExpressiveNames => [SIMILAR_NAMES, MANY_SINGLE_CHAR_NAMES, JUST_UNDERSCORES_AND_DIGITS]);
-
 impl NonExpressiveNames {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 3c4dfade3439..c6ed0082016f 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -54,6 +54,8 @@ declare_clippy_lint! {
     "there is a field that is not safe to be sent to another thread in a `Send` struct"
 }
 
+impl_lint_pass!(NonSendFieldInSendTy => [NON_SEND_FIELDS_IN_SEND_TY]);
+
 pub struct NonSendFieldInSendTy {
     enable_raw_pointer_heuristic: bool,
 }
@@ -66,8 +68,6 @@ impl NonSendFieldInSendTy {
     }
 }
 
-impl_lint_pass!(NonSendFieldInSendTy => [NON_SEND_FIELDS_IN_SEND_TY]);
-
 impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         let ty_allowed_in_send = if self.enable_raw_pointer_heuristic {
diff --git a/clippy_lints/src/non_std_lazy_statics.rs b/clippy_lints/src/non_std_lazy_statics.rs
index 61e4d419fdf0..487eaecf1889 100644
--- a/clippy_lints/src/non_std_lazy_statics.rs
+++ b/clippy_lints/src/non_std_lazy_statics.rs
@@ -45,6 +45,8 @@ declare_clippy_lint! {
     "lazy static that could be replaced by `std::sync::LazyLock`"
 }
 
+impl_lint_pass!(NonStdLazyStatic => [NON_STD_LAZY_STATICS]);
+
 /// A list containing functions with corresponding replacements in `LazyLock`.
 ///
 /// Some functions could be replaced as well if we have replaced `Lazy` to `LazyLock`,
@@ -83,8 +85,6 @@ impl NonStdLazyStatic {
     }
 }
 
-impl_lint_pass!(NonStdLazyStatic => [NON_STD_LAZY_STATICS]);
-
 fn can_use_lazy_cell(cx: &LateContext<'_>, msrv: Msrv) -> bool {
     msrv.meets(cx, msrvs::LAZY_CELL) && !is_no_std_crate(cx)
 }
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 8970970f4b47..b449681ae2e1 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -33,6 +33,8 @@ declare_clippy_lint! {
     "check consistent use of braces in macro"
 }
 
+impl_lint_pass!(MacroBraces => [NONSTANDARD_MACRO_BRACES]);
+
 struct MacroInfo {
     callsite_span: Span,
     callsite_snippet: SourceText,
@@ -54,8 +56,6 @@ impl MacroBraces {
     }
 }
 
-impl_lint_pass!(MacroBraces => [NONSTANDARD_MACRO_BRACES]);
-
 impl EarlyLintPass for MacroBraces {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
         if let Some(MacroInfo {
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index f756f94d97b3..8b0743c8d9d5 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -164,7 +164,11 @@ declare_clippy_lint! {
     pedantic,
     "self receiver only used to recursively call method can be removed"
 }
-impl_lint_pass!(OnlyUsedInRecursion => [ONLY_USED_IN_RECURSION, SELF_ONLY_USED_IN_RECURSION]);
+
+impl_lint_pass!(OnlyUsedInRecursion => [
+    ONLY_USED_IN_RECURSION,
+    SELF_ONLY_USED_IN_RECURSION,
+]);
 
 #[derive(Clone, Copy)]
 enum FnKind {
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 5b00f1b0bd13..567443b8e86d 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -103,25 +103,6 @@ declare_clippy_lint! {
     "any arithmetic expression that can cause side effects like overflows or panics"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for float arithmetic.
-    ///
-    /// ### Why restrict this?
-    /// For some embedded systems or kernel development, it
-    /// can be useful to rule out floating-point numbers.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let a = 0.0;
-    /// a + 1.0;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FLOAT_ARITHMETIC,
-    restriction,
-    "any floating-point arithmetic statement"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `a = a op b` or `a = b commutative_op a`
@@ -157,33 +138,6 @@ declare_clippy_lint! {
     "assigning the result of an operation on a variable to that same variable"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `a op= a op b` or `a op= b op a` patterns.
-    ///
-    /// ### Why is this bad?
-    /// Most likely these are bugs where one meant to write `a
-    /// op= b`.
-    ///
-    /// ### Known problems
-    /// Clippy cannot know for sure if `a op= a op b` should have
-    /// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.
-    /// If `a op= a op b` is really the correct behavior it should be
-    /// written as `a = a op a op b` as it's less confusing.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let mut a = 5;
-    /// let b = 2;
-    /// // ...
-    /// a += a + b;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MISREFACTORED_ASSIGN_OP,
-    suspicious,
-    "having a variable on both sides of an assign op"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for incompatible bit masks in comparisons.
@@ -224,69 +178,53 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for bit masks in comparisons which can be removed
-    /// without changing the outcome. The basic structure can be seen in the
-    /// following table:
-    ///
-    /// |Comparison| Bit Op   |Example     |equals |
-    /// |----------|----------|------------|-------|
-    /// |`>` / `<=`|`\|` / `^`|`x \| 2 > 3`|`x > 3`|
-    /// |`<` / `>=`|`\|` / `^`|`x ^ 1 < 4` |`x < 4`|
+    /// Checks for conversions to owned values just for the sake
+    /// of a comparison.
     ///
     /// ### Why is this bad?
-    /// Not equally evil as [`bad_bit_mask`](#bad_bit_mask),
-    /// but still a bit misleading, because the bit mask is ineffective.
-    ///
-    /// ### Known problems
-    /// False negatives: This lint will only match instances
-    /// where we have figured out the math (which is for a power-of-two compared
-    /// value). This means things like `x | 1 >= 7` (which would be better written
-    /// as `x >= 6`) will not be reported (but bit masks like this are fairly
-    /// uncommon).
+    /// The comparison can operate on a reference, so creating
+    /// an owned value effectively throws it away directly afterwards, which is
+    /// needlessly consuming code and heap space.
     ///
     /// ### Example
     /// ```no_run
-    /// # let x = 1;
-    /// if (x | 1 > 3) {  }
+    /// # let x = "foo";
+    /// # let y = String::from("foo");
+    /// if x.to_owned() == y {}
     /// ```
     ///
     /// Use instead:
-    ///
     /// ```no_run
-    /// # let x = 1;
-    /// if (x >= 2) {  }
+    /// # let x = "foo";
+    /// # let y = String::from("foo");
+    /// if x == y {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub INEFFECTIVE_BIT_MASK,
-    correctness,
-    "expressions where a bit mask will be rendered useless by a comparison, e.g., `(x | 1) > 2`"
+    pub CMP_OWNED,
+    perf,
+    "creating owned instances for comparing with others, e.g., `x == \"foo\".to_string()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for bit masks that can be replaced by a call
-    /// to `trailing_zeros`
+    /// Checks for decimal literals used as bit masks in bitwise operations.
     ///
     /// ### Why is this bad?
-    /// `x.trailing_zeros() >= 4` is much clearer than `x & 15
-    /// == 0`
+    /// Using decimal literals for bit masks can make the code less readable and obscure the intended bit pattern.
+    /// Binary, hexadecimal, or octal literals make the bit pattern more explicit and easier to understand at a glance.
     ///
     /// ### Example
-    /// ```no_run
-    /// # let x = 1;
-    /// if x & 0b1111 == 0 { }
+    /// ```rust,no_run
+    /// let a = 14 & 6; // Bit pattern is not immediately clear
     /// ```
-    ///
     /// Use instead:
-    ///
-    /// ```no_run
-    /// # let x: i32 = 1;
-    /// if x.trailing_zeros() >= 4 { }
+    /// ```rust,no_run
+    /// let a = 0b1110 & 0b0110;
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub VERBOSE_BIT_MASK,
+    #[clippy::version = "1.93.0"]
+    pub DECIMAL_BITWISE_OPERANDS,
     pedantic,
-    "expressions where a bit mask is less readable than the corresponding method call"
+    "use binary, hex, or octal literals for bitwise operations"
 }
 
 declare_clippy_lint! {
@@ -317,45 +255,6 @@ declare_clippy_lint! {
     "unnecessary double comparisons that can be simplified"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for double comparisons that can never succeed
-    ///
-    /// ### Why is this bad?
-    /// The whole expression can be replaced by `false`,
-    /// which is probably not the programmer's intention
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let status_code = 200;
-    /// if status_code <= 400 && status_code > 500 {}
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub IMPOSSIBLE_COMPARISONS,
-    correctness,
-    "double comparisons that will never evaluate to `true`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for ineffective double comparisons against constants.
-    ///
-    /// ### Why is this bad?
-    /// Only one of the comparisons has any effect on the result, the programmer
-    /// probably intended to flip one of the comparison operators, or compare a
-    /// different value entirely.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let status_code = 200;
-    /// if status_code <= 400 && status_code < 500 {}
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub REDUNDANT_COMPARISONS,
-    correctness,
-    "double comparisons where one of them can be removed"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calculation of subsecond microseconds or milliseconds
@@ -418,30 +317,6 @@ declare_clippy_lint! {
     "equal operands on both sides of a comparison or bitwise combination (e.g., `x == x`)"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for arguments to `==` which have their address
-    /// taken to satisfy a bound
-    /// and suggests to dereference the other argument instead
-    ///
-    /// ### Why is this bad?
-    /// It is more idiomatic to dereference the other argument.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// &x == y
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// x == *y
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OP_REF,
-    style,
-    "taking a reference to satisfy the type constraints on `==`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for erasing operations, e.g., `x * 0`.
@@ -466,135 +341,47 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for statements of the form `(a - b) < f32::EPSILON` or
-    /// `(a - b) < f64::EPSILON`. Note the missing `.abs()`.
-    ///
-    /// ### Why is this bad?
-    /// The code without `.abs()` is more likely to have a bug.
+    /// Checks for float arithmetic.
     ///
-    /// ### Known problems
-    /// If the user can ensure that b is larger than a, the `.abs()` is
-    /// technically unnecessary. However, it will make the code more robust and doesn't have any
-    /// large performance implications. If the abs call was deliberately left out for performance
-    /// reasons, it is probably better to state this explicitly in the code, which then can be done
-    /// with an allow.
+    /// ### Why restrict this?
+    /// For some embedded systems or kernel development, it
+    /// can be useful to rule out floating-point numbers.
     ///
     /// ### Example
     /// ```no_run
-    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
-    ///     (a - b) < f32::EPSILON
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
-    ///     (a - b).abs() < f32::EPSILON
-    /// }
+    /// # let a = 0.0;
+    /// a + 1.0;
     /// ```
-    #[clippy::version = "1.48.0"]
-    pub FLOAT_EQUALITY_WITHOUT_ABS,
-    suspicious,
-    "float equality check without `.abs()`"
+    #[clippy::version = "pre 1.29.0"]
+    pub FLOAT_ARITHMETIC,
+    restriction,
+    "any floating-point arithmetic statement"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for identity operations, e.g., `x + 0`.
+    /// Checks for (in-)equality comparisons on floating-point
+    /// values (apart from zero), except in functions called `*eq*` (which probably
+    /// implement equality for a type involving floats).
     ///
     /// ### Why is this bad?
-    /// This code can be removed without changing the
-    /// meaning. So it just obscures what's going on. Delete it mercilessly.
+    /// Floating point calculations are usually imprecise, so asking if two values are *exactly*
+    /// equal is asking for trouble because arriving at the same logical result via different
+    /// routes (e.g. calculation versus constant) may yield different values.
     ///
     /// ### Example
+    ///
     /// ```no_run
-    /// # let x = 1;
-    /// x / 1 + 0 * 1 - 0 | 0;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub IDENTITY_OP,
-    complexity,
-    "using identity operations, e.g., `x + 0` or `y / 1`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for division of integers
+    /// let a: f64 = 1000.1;
+    /// let b: f64 = 0.2;
+    /// let x = a + b;
+    /// let y = 1000.3; // Expected value.
     ///
-    /// ### Why restrict this?
-    /// When outside of some very specific algorithms,
-    /// integer division is very often a mistake because it discards the
-    /// remainder.
+    /// // Actual value: 1000.3000000000001
+    /// println!("{x}");
     ///
-    /// ### Example
-    /// ```no_run
-    /// let x = 3 / 2;
-    /// println!("{}", x);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let x = 3f32 / 2f32;
-    /// println!("{}", x);
-    /// ```
-    #[clippy::version = "1.37.0"]
-    pub INTEGER_DIVISION,
-    restriction,
-    "integer division may cause loss of precision"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for conversions to owned values just for the sake
-    /// of a comparison.
-    ///
-    /// ### Why is this bad?
-    /// The comparison can operate on a reference, so creating
-    /// an owned value effectively throws it away directly afterwards, which is
-    /// needlessly consuming code and heap space.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let x = "foo";
-    /// # let y = String::from("foo");
-    /// if x.to_owned() == y {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let x = "foo";
-    /// # let y = String::from("foo");
-    /// if x == y {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub CMP_OWNED,
-    perf,
-    "creating owned instances for comparing with others, e.g., `x == \"foo\".to_string()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for (in-)equality comparisons on floating-point
-    /// values (apart from zero), except in functions called `*eq*` (which probably
-    /// implement equality for a type involving floats).
-    ///
-    /// ### Why is this bad?
-    /// Floating point calculations are usually imprecise, so asking if two values are *exactly*
-    /// equal is asking for trouble because arriving at the same logical result via different
-    /// routes (e.g. calculation versus constant) may yield different values.
-    ///
-    /// ### Example
-    ///
-    /// ```no_run
-    /// let a: f64 = 1000.1;
-    /// let b: f64 = 0.2;
-    /// let x = a + b;
-    /// let y = 1000.3; // Expected value.
-    ///
-    /// // Actual value: 1000.3000000000001
-    /// println!("{x}");
-    ///
-    /// let are_equal = x == y;
-    /// println!("{are_equal}"); // false
+    /// let are_equal = x == y;
+    /// println!("{are_equal}"); // false
     /// ```
     ///
     /// The correct way to compare floating point numbers is to define an allowed error margin. This
@@ -699,184 +486,199 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for getting the remainder of integer division by one or minus
-    /// one.
+    /// Checks for statements of the form `(a - b) < f32::EPSILON` or
+    /// `(a - b) < f64::EPSILON`. Note the missing `.abs()`.
     ///
     /// ### Why is this bad?
-    /// The result for a divisor of one can only ever be zero; for
-    /// minus one it can cause panic/overflow (if the left operand is the minimal value of
-    /// the respective integer type) or results in zero. No one will write such code
-    /// deliberately, unless trying to win an Underhanded Rust Contest. Even for that
-    /// contest, it's probably a bad idea. Use something more underhanded.
+    /// The code without `.abs()` is more likely to have a bug.
+    ///
+    /// ### Known problems
+    /// If the user can ensure that b is larger than a, the `.abs()` is
+    /// technically unnecessary. However, it will make the code more robust and doesn't have any
+    /// large performance implications. If the abs call was deliberately left out for performance
+    /// reasons, it is probably better to state this explicitly in the code, which then can be done
+    /// with an allow.
     ///
     /// ### Example
     /// ```no_run
-    /// # let x = 1;
-    /// let a = x % 1;
-    /// let a = x % -1;
+    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+    ///     (a - b) < f32::EPSILON
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MODULO_ONE,
-    correctness,
-    "taking an integer modulo +/-1, which can either panic/overflow or always returns 0"
+    /// Use instead:
+    /// ```no_run
+    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+    ///     (a - b).abs() < f32::EPSILON
+    /// }
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub FLOAT_EQUALITY_WITHOUT_ABS,
+    suspicious,
+    "float equality check without `.abs()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for modulo arithmetic.
-    ///
-    /// ### Why restrict this?
-    /// The results of modulo (`%`) operation might differ
-    /// depending on the language, when negative numbers are involved.
-    /// If you interop with different languages it might be beneficial
-    /// to double check all places that use modulo arithmetic.
+    /// Checks for identity operations, e.g., `x + 0`.
     ///
-    /// For example, in Rust `17 % -3 = 2`, but in Python `17 % -3 = -1`.
+    /// ### Why is this bad?
+    /// This code can be removed without changing the
+    /// meaning. So it just obscures what's going on. Delete it mercilessly.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = -17 % 3;
+    /// # let x = 1;
+    /// x / 1 + 0 * 1 - 0 | 0;
     /// ```
-    #[clippy::version = "1.42.0"]
-    pub MODULO_ARITHMETIC,
-    restriction,
-    "any modulo arithmetic statement"
+    #[clippy::version = "pre 1.29.0"]
+    pub IDENTITY_OP,
+    complexity,
+    "using identity operations, e.g., `x + 0` or `y / 1`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of bitwise and/or operators between booleans, where performance may be improved by using
-    /// a lazy and.
+    /// Checks for double comparisons that can never succeed
     ///
     /// ### Why is this bad?
-    /// The bitwise operators do not support short-circuiting, so it may hinder code performance.
-    /// Additionally, boolean logic "masked" as bitwise logic is not caught by lints like `unnecessary_fold`
-    ///
-    /// ### Known problems
-    /// This lint evaluates only when the right side is determined to have no side effects. At this time, that
-    /// determination is quite conservative.
+    /// The whole expression can be replaced by `false`,
+    /// which is probably not the programmer's intention
     ///
     /// ### Example
     /// ```no_run
-    /// let (x,y) = (true, false);
-    /// if x & !y {} // where both x and y are booleans
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let (x,y) = (true, false);
-    /// if x && !y {}
+    /// # let status_code = 200;
+    /// if status_code <= 400 && status_code > 500 {}
     /// ```
-    #[clippy::version = "1.54.0"]
-    pub NEEDLESS_BITWISE_BOOL,
-    pedantic,
-    "Boolean expressions that use bitwise rather than lazy operators"
+    #[clippy::version = "1.73.0"]
+    pub IMPOSSIBLE_COMPARISONS,
+    correctness,
+    "double comparisons that will never evaluate to `true`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for explicit self-assignments.
+    /// Checks for bit masks in comparisons which can be removed
+    /// without changing the outcome. The basic structure can be seen in the
+    /// following table:
+    ///
+    /// |Comparison| Bit Op   |Example     |equals |
+    /// |----------|----------|------------|-------|
+    /// |`>` / `<=`|`\|` / `^`|`x \| 2 > 3`|`x > 3`|
+    /// |`<` / `>=`|`\|` / `^`|`x ^ 1 < 4` |`x < 4`|
     ///
     /// ### Why is this bad?
-    /// Self-assignments are redundant and unlikely to be
-    /// intentional.
+    /// Not equally evil as [`bad_bit_mask`](#bad_bit_mask),
+    /// but still a bit misleading, because the bit mask is ineffective.
     ///
     /// ### Known problems
-    /// If expression contains any deref coercions or
-    /// indexing operations they are assumed not to have any side effects.
+    /// False negatives: This lint will only match instances
+    /// where we have figured out the math (which is for a power-of-two compared
+    /// value). This means things like `x | 1 >= 7` (which would be better written
+    /// as `x >= 6`) will not be reported (but bit masks like this are fairly
+    /// uncommon).
     ///
     /// ### Example
     /// ```no_run
-    /// struct Event {
-    ///     x: i32,
-    /// }
-    ///
-    /// fn copy_position(a: &mut Event, b: &Event) {
-    ///     a.x = a.x;
-    /// }
+    /// # let x = 1;
+    /// if (x | 1 > 3) {  }
     /// ```
     ///
-    /// Should be:
-    /// ```no_run
-    /// struct Event {
-    ///     x: i32,
-    /// }
+    /// Use instead:
     ///
-    /// fn copy_position(a: &mut Event, b: &Event) {
-    ///     a.x = b.x;
-    /// }
+    /// ```no_run
+    /// # let x = 1;
+    /// if (x >= 2) {  }
     /// ```
-    #[clippy::version = "1.48.0"]
-    pub SELF_ASSIGNMENT,
+    #[clippy::version = "pre 1.29.0"]
+    pub INEFFECTIVE_BIT_MASK,
     correctness,
-    "explicit self-assignment"
+    "expressions where a bit mask will be rendered useless by a comparison, e.g., `(x | 1) > 2`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for manual implementation of `midpoint`.
+    /// Checks for division of integers
     ///
-    /// ### Why is this bad?
-    /// Using `(x + y) / 2` might cause an overflow on the intermediate
-    /// addition result.
+    /// ### Why restrict this?
+    /// When outside of some very specific algorithms,
+    /// integer division is very often a mistake because it discards the
+    /// remainder.
     ///
     /// ### Example
     /// ```no_run
-    /// # let a: u32 = 0;
-    /// let c = (a + 10) / 2;
+    /// let x = 3 / 2;
+    /// println!("{}", x);
     /// ```
+    ///
     /// Use instead:
     /// ```no_run
-    /// # let a: u32 = 0;
-    /// let c = u32::midpoint(a, 10);
+    /// let x = 3f32 / 2f32;
+    /// println!("{}", x);
     /// ```
-    #[clippy::version = "1.87.0"]
-    pub MANUAL_MIDPOINT,
-    pedantic,
-    "manual implementation of `midpoint` which can overflow"
+    #[clippy::version = "1.37.0"]
+    pub INTEGER_DIVISION,
+    restriction,
+    "integer division may cause loss of precision"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for manual implementation of `.is_multiple_of()` on
-    /// unsigned integer types.
+    /// Checks for the usage of division (`/`) and remainder (`%`) operations
+    /// when performed on any integer types using the default `Div` and `Rem` trait implementations.
     ///
-    /// ### Why is this bad?
-    /// `a.is_multiple_of(b)` is a clearer way to check for divisibility
-    /// of `a` by `b`. This expression can never panic.
+    /// ### Why restrict this?
+    /// In cryptographic contexts, division can result in timing sidechannel vulnerabilities,
+    /// and needs to be replaced with constant-time code instead (e.g. Barrett reduction).
     ///
     /// ### Example
     /// ```no_run
-    /// # let (a, b) = (3u64, 4u64);
-    /// if a % b == 0 {
-    ///     println!("{a} is divisible by {b}");
-    /// }
+    /// let my_div = 10 / 2;
     /// ```
     /// Use instead:
     /// ```no_run
-    /// # let (a, b) = (3u64, 4u64);
-    /// if a.is_multiple_of(b) {
-    ///     println!("{a} is divisible by {b}");
-    /// }
+    /// let my_div = 10 >> 1;
     /// ```
-    #[clippy::version = "1.90.0"]
-    pub MANUAL_IS_MULTIPLE_OF,
-    complexity,
-    "manual implementation of `.is_multiple_of()`"
+    #[clippy::version = "1.79.0"]
+    pub INTEGER_DIVISION_REMAINDER_USED,
+    restriction,
+    "use of disallowed default division and remainder operations"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for an expression like `(x + (y - 1)) / y` which is a common manual reimplementation
-    /// of `x.div_ceil(y)`.
+    /// Checks for comparisons where the relation is always either
+    /// true or false, but where one side has been upcast so that the comparison is
+    /// necessary. Only integer types are checked.
     ///
     /// ### Why is this bad?
-    /// It's simpler, clearer and more readable.
+    /// An expression like `let x : u8 = ...; (x as u32) > 300`
+    /// will mistakenly imply that it is possible for `x` to be outside the range of
+    /// `u8`.
     ///
     /// ### Example
     /// ```no_run
-    /// let x: i32 = 7;
-    /// let y: i32 = 4;
-    /// let div = (x + (y - 1)) / y;
+    /// let x: u8 = 1;
+    /// (x as u32) > 300;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub INVALID_UPCAST_COMPARISONS,
+    pedantic,
+    "a comparison involving an upcast which is always true or false"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for an expression like `(x + (y - 1)) / y` which is a common manual reimplementation
+    /// of `x.div_ceil(y)`.
+    ///
+    /// ### Why is this bad?
+    /// It's simpler, clearer and more readable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: i32 = 7;
+    /// let y: i32 = 4;
+    /// let div = (x + (y - 1)) / y;
     /// ```
     /// Use instead:
     /// ```no_run
@@ -893,123 +695,321 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for comparisons where the relation is always either
-    /// true or false, but where one side has been upcast so that the comparison is
-    /// necessary. Only integer types are checked.
+    /// Checks for manual implementation of `.is_multiple_of()` on
+    /// unsigned integer types.
     ///
     /// ### Why is this bad?
-    /// An expression like `let x : u8 = ...; (x as u32) > 300`
-    /// will mistakenly imply that it is possible for `x` to be outside the range of
-    /// `u8`.
+    /// `a.is_multiple_of(b)` is a clearer way to check for divisibility
+    /// of `a` by `b`. This expression can never panic.
     ///
     /// ### Example
     /// ```no_run
-    /// let x: u8 = 1;
-    /// (x as u32) > 300;
+    /// # let (a, b) = (3u64, 4u64);
+    /// if a % b == 0 {
+    ///     println!("{a} is divisible by {b}");
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub INVALID_UPCAST_COMPARISONS,
-    pedantic,
-    "a comparison involving an upcast which is always true or false"
+    /// Use instead:
+    /// ```no_run
+    /// # let (a, b) = (3u64, 4u64);
+    /// if a.is_multiple_of(b) {
+    ///     println!("{a} is divisible by {b}");
+    /// }
+    /// ```
+    #[clippy::version = "1.90.0"]
+    pub MANUAL_IS_MULTIPLE_OF,
+    complexity,
+    "manual implementation of `.is_multiple_of()`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of division (`/`) and remainder (`%`) operations
-    /// when performed on any integer types using the default `Div` and `Rem` trait implementations.
+    /// Checks for manual implementation of `midpoint`.
     ///
-    /// ### Why restrict this?
-    /// In cryptographic contexts, division can result in timing sidechannel vulnerabilities,
-    /// and needs to be replaced with constant-time code instead (e.g. Barrett reduction).
+    /// ### Why is this bad?
+    /// Using `(x + y) / 2` might cause an overflow on the intermediate
+    /// addition result.
     ///
     /// ### Example
     /// ```no_run
-    /// let my_div = 10 / 2;
+    /// # let a: u32 = 0;
+    /// let c = (a + 10) / 2;
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let my_div = 10 >> 1;
+    /// # let a: u32 = 0;
+    /// let c = u32::midpoint(a, 10);
     /// ```
-    #[clippy::version = "1.79.0"]
-    pub INTEGER_DIVISION_REMAINDER_USED,
+    #[clippy::version = "1.87.0"]
+    pub MANUAL_MIDPOINT,
+    pedantic,
+    "manual implementation of `midpoint` which can overflow"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `a op= a op b` or `a op= b op a` patterns.
+    ///
+    /// ### Why is this bad?
+    /// Most likely these are bugs where one meant to write `a
+    /// op= b`.
+    ///
+    /// ### Known problems
+    /// Clippy cannot know for sure if `a op= a op b` should have
+    /// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.
+    /// If `a op= a op b` is really the correct behavior it should be
+    /// written as `a = a op a op b` as it's less confusing.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let mut a = 5;
+    /// let b = 2;
+    /// // ...
+    /// a += a + b;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MISREFACTORED_ASSIGN_OP,
+    suspicious,
+    "having a variable on both sides of an assign op"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for modulo arithmetic.
+    ///
+    /// ### Why restrict this?
+    /// The results of modulo (`%`) operation might differ
+    /// depending on the language, when negative numbers are involved.
+    /// If you interop with different languages it might be beneficial
+    /// to double check all places that use modulo arithmetic.
+    ///
+    /// For example, in Rust `17 % -3 = 2`, but in Python `17 % -3 = -1`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = -17 % 3;
+    /// ```
+    #[clippy::version = "1.42.0"]
+    pub MODULO_ARITHMETIC,
     restriction,
-    "use of disallowed default division and remainder operations"
+    "any modulo arithmetic statement"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for decimal literals used as bit masks in bitwise operations.
+    /// Checks for getting the remainder of integer division by one or minus
+    /// one.
     ///
     /// ### Why is this bad?
-    /// Using decimal literals for bit masks can make the code less readable and obscure the intended bit pattern.
-    /// Binary, hexadecimal, or octal literals make the bit pattern more explicit and easier to understand at a glance.
+    /// The result for a divisor of one can only ever be zero; for
+    /// minus one it can cause panic/overflow (if the left operand is the minimal value of
+    /// the respective integer type) or results in zero. No one will write such code
+    /// deliberately, unless trying to win an Underhanded Rust Contest. Even for that
+    /// contest, it's probably a bad idea. Use something more underhanded.
     ///
     /// ### Example
-    /// ```rust,no_run
-    /// let a = 14 & 6; // Bit pattern is not immediately clear
+    /// ```no_run
+    /// # let x = 1;
+    /// let a = x % 1;
+    /// let a = x % -1;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MODULO_ONE,
+    correctness,
+    "taking an integer modulo +/-1, which can either panic/overflow or always returns 0"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of bitwise and/or operators between booleans, where performance may be improved by using
+    /// a lazy and.
+    ///
+    /// ### Why is this bad?
+    /// The bitwise operators do not support short-circuiting, so it may hinder code performance.
+    /// Additionally, boolean logic "masked" as bitwise logic is not caught by lints like `unnecessary_fold`
+    ///
+    /// ### Known problems
+    /// This lint evaluates only when the right side is determined to have no side effects. At this time, that
+    /// determination is quite conservative.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let (x,y) = (true, false);
+    /// if x & !y {} // where both x and y are booleans
     /// ```
     /// Use instead:
-    /// ```rust,no_run
-    /// let a = 0b1110 & 0b0110;
+    /// ```no_run
+    /// let (x,y) = (true, false);
+    /// if x && !y {}
     /// ```
-    #[clippy::version = "1.93.0"]
-    pub DECIMAL_BITWISE_OPERANDS,
+    #[clippy::version = "1.54.0"]
+    pub NEEDLESS_BITWISE_BOOL,
     pedantic,
-    "use binary, hex, or octal literals for bitwise operations"
+    "Boolean expressions that use bitwise rather than lazy operators"
 }
 
-pub struct Operators {
-    arithmetic_context: numeric_arithmetic::Context,
-    verbose_bit_mask_threshold: u64,
-    modulo_arithmetic_allow_comparison_to_zero: bool,
-    msrv: Msrv,
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for arguments to `==` which have their address
+    /// taken to satisfy a bound
+    /// and suggests to dereference the other argument instead
+    ///
+    /// ### Why is this bad?
+    /// It is more idiomatic to dereference the other argument.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// &x == y
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// x == *y
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub OP_REF,
+    style,
+    "taking a reference to satisfy the type constraints on `==`"
 }
 
-impl Operators {
-    pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            arithmetic_context: numeric_arithmetic::Context::default(),
-            verbose_bit_mask_threshold: conf.verbose_bit_mask_threshold,
-            modulo_arithmetic_allow_comparison_to_zero: conf.allow_comparison_to_zero,
-            msrv: conf.msrv,
-        }
-    }
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for ineffective double comparisons against constants.
+    ///
+    /// ### Why is this bad?
+    /// Only one of the comparisons has any effect on the result, the programmer
+    /// probably intended to flip one of the comparison operators, or compare a
+    /// different value entirely.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let status_code = 200;
+    /// if status_code <= 400 && status_code < 500 {}
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub REDUNDANT_COMPARISONS,
+    correctness,
+    "double comparisons where one of them can be removed"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for explicit self-assignments.
+    ///
+    /// ### Why is this bad?
+    /// Self-assignments are redundant and unlikely to be
+    /// intentional.
+    ///
+    /// ### Known problems
+    /// If expression contains any deref coercions or
+    /// indexing operations they are assumed not to have any side effects.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// struct Event {
+    ///     x: i32,
+    /// }
+    ///
+    /// fn copy_position(a: &mut Event, b: &Event) {
+    ///     a.x = a.x;
+    /// }
+    /// ```
+    ///
+    /// Should be:
+    /// ```no_run
+    /// struct Event {
+    ///     x: i32,
+    /// }
+    ///
+    /// fn copy_position(a: &mut Event, b: &Event) {
+    ///     a.x = b.x;
+    /// }
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub SELF_ASSIGNMENT,
+    correctness,
+    "explicit self-assignment"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for bit masks that can be replaced by a call
+    /// to `trailing_zeros`
+    ///
+    /// ### Why is this bad?
+    /// `x.trailing_zeros() >= 4` is much clearer than `x & 15
+    /// == 0`
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let x = 1;
+    /// if x & 0b1111 == 0 { }
+    /// ```
+    ///
+    /// Use instead:
+    ///
+    /// ```no_run
+    /// # let x: i32 = 1;
+    /// if x.trailing_zeros() >= 4 { }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub VERBOSE_BIT_MASK,
+    pedantic,
+    "expressions where a bit mask is less readable than the corresponding method call"
 }
 
 impl_lint_pass!(Operators => [
     ABSURD_EXTREME_COMPARISONS,
     ARITHMETIC_SIDE_EFFECTS,
-    FLOAT_ARITHMETIC,
     ASSIGN_OP_PATTERN,
-    MISREFACTORED_ASSIGN_OP,
     BAD_BIT_MASK,
-    INEFFECTIVE_BIT_MASK,
-    VERBOSE_BIT_MASK,
+    CMP_OWNED,
+    DECIMAL_BITWISE_OPERANDS,
     DOUBLE_COMPARISONS,
-    IMPOSSIBLE_COMPARISONS,
-    REDUNDANT_COMPARISONS,
     DURATION_SUBSEC,
     EQ_OP,
-    OP_REF,
     ERASING_OP,
+    FLOAT_ARITHMETIC,
+    FLOAT_CMP,
+    FLOAT_CMP_CONST,
     FLOAT_EQUALITY_WITHOUT_ABS,
     IDENTITY_OP,
+    IMPOSSIBLE_COMPARISONS,
+    INEFFECTIVE_BIT_MASK,
     INTEGER_DIVISION,
     INTEGER_DIVISION_REMAINDER_USED,
-    CMP_OWNED,
-    FLOAT_CMP,
-    FLOAT_CMP_CONST,
-    MODULO_ONE,
+    INVALID_UPCAST_COMPARISONS,
+    MANUAL_DIV_CEIL,
+    MANUAL_IS_MULTIPLE_OF,
+    MANUAL_MIDPOINT,
+    MISREFACTORED_ASSIGN_OP,
     MODULO_ARITHMETIC,
+    MODULO_ONE,
     NEEDLESS_BITWISE_BOOL,
+    OP_REF,
+    REDUNDANT_COMPARISONS,
     SELF_ASSIGNMENT,
-    MANUAL_MIDPOINT,
-    MANUAL_IS_MULTIPLE_OF,
-    MANUAL_DIV_CEIL,
-    INVALID_UPCAST_COMPARISONS,
-    DECIMAL_BITWISE_OPERANDS
+    VERBOSE_BIT_MASK,
 ]);
 
+pub struct Operators {
+    arithmetic_context: numeric_arithmetic::Context,
+    verbose_bit_mask_threshold: u64,
+    modulo_arithmetic_allow_comparison_to_zero: bool,
+    msrv: Msrv,
+}
+
+impl Operators {
+    pub fn new(conf: &'static Conf) -> Self {
+        Self {
+            arithmetic_context: numeric_arithmetic::Context::default(),
+            verbose_bit_mask_threshold: conf.verbose_bit_mask_threshold,
+            modulo_arithmetic_allow_comparison_to_zero: conf.allow_comparison_to_zero,
+            msrv: conf.msrv,
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for Operators {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         eq_op::check_assert(cx, e);
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 57127e9d2298..cc147a4a84bd 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -40,7 +40,7 @@ declare_clippy_lint! {
     "functions of type `Result<..>` that contain `panic!()` or assertion"
 }
 
-declare_lint_pass!(PanicInResultFn  => [PANIC_IN_RESULT_FN]);
+declare_lint_pass!(PanicInResultFn => [PANIC_IN_RESULT_FN]);
 
 impl<'tcx> LateLintPass<'tcx> for PanicInResultFn {
     fn check_fn(
diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 43db0085f2e3..b60c5f9a60d9 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -39,41 +39,41 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `unimplemented!`.
+    /// Checks for usage of `todo!`.
     ///
     /// ### Why restrict this?
-    /// This macro, or panics in general, may be unwanted in production code.
+    /// The `todo!` macro indicates the presence of unfinished code,
+    /// so it should not be present in production code.
     ///
     /// ### Example
     /// ```no_run
+    /// todo!();
+    /// ```
+    /// Finish the implementation, or consider marking it as explicitly unimplemented.
+    /// ```no_run
     /// unimplemented!();
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub UNIMPLEMENTED,
+    #[clippy::version = "1.40.0"]
+    pub TODO,
     restriction,
-    "`unimplemented!` should not be present in production code"
+    "`todo!` should not be present in production code"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `todo!`.
+    /// Checks for usage of `unimplemented!`.
     ///
     /// ### Why restrict this?
-    /// The `todo!` macro indicates the presence of unfinished code,
-    /// so it should not be present in production code.
+    /// This macro, or panics in general, may be unwanted in production code.
     ///
     /// ### Example
     /// ```no_run
-    /// todo!();
-    /// ```
-    /// Finish the implementation, or consider marking it as explicitly unimplemented.
-    /// ```no_run
     /// unimplemented!();
     /// ```
-    #[clippy::version = "1.40.0"]
-    pub TODO,
+    #[clippy::version = "pre 1.29.0"]
+    pub UNIMPLEMENTED,
     restriction,
-    "`todo!` should not be present in production code"
+    "`unimplemented!` should not be present in production code"
 }
 
 declare_clippy_lint! {
@@ -93,7 +93,7 @@ declare_clippy_lint! {
     "usage of the `unreachable!` macro"
 }
 
-impl_lint_pass!(PanicUnimplemented => [UNIMPLEMENTED, UNREACHABLE, TODO, PANIC]);
+impl_lint_pass!(PanicUnimplemented => [PANIC, TODO, UNIMPLEMENTED, UNREACHABLE]);
 
 impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/partial_pub_fields.rs b/clippy_lints/src/partial_pub_fields.rs
index 65e93af9420d..4428e07f7995 100644
--- a/clippy_lints/src/partial_pub_fields.rs
+++ b/clippy_lints/src/partial_pub_fields.rs
@@ -37,6 +37,7 @@ declare_clippy_lint! {
     restriction,
     "partial fields of a struct are public"
 }
+
 declare_lint_pass!(PartialPubFields => [PARTIAL_PUB_FIELDS]);
 
 impl EarlyLintPass for PartialPubFields {
diff --git a/clippy_lints/src/partialeq_to_none.rs b/clippy_lints/src/partialeq_to_none.rs
index 44217ac2c4fc..72d2fdeda21c 100644
--- a/clippy_lints/src/partialeq_to_none.rs
+++ b/clippy_lints/src/partialeq_to_none.rs
@@ -37,6 +37,7 @@ declare_clippy_lint! {
     style,
     "Binary comparison to `Option<T>::None` relies on `T: PartialEq`, which is unneeded"
 }
+
 declare_lint_pass!(PartialeqToNone => [PARTIALEQ_TO_NONE]);
 
 impl<'tcx> LateLintPass<'tcx> for PartialeqToNone {
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 6e9142b22e0e..8b4c216840d9 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -20,6 +20,39 @@ use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, sym};
 use std::iter;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for functions taking arguments by value, where
+    /// the argument type is `Copy` and large enough to be worth considering
+    /// passing by reference. Does not trigger if the function is being exported,
+    /// because that might induce API breakage, if the parameter is declared as mutable,
+    /// or if the argument is a `self`.
+    ///
+    /// ### Why is this bad?
+    /// Arguments passed by value might result in an unnecessary
+    /// shallow copy, taking up more space in the stack and requiring a call to
+    /// `memcpy`, which can be expensive.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[derive(Clone, Copy)]
+    /// struct TooLarge([u8; 2048]);
+    ///
+    /// fn foo(v: TooLarge) {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # #[derive(Clone, Copy)]
+    /// # struct TooLarge([u8; 2048]);
+    /// fn foo(v: &TooLarge) {}
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub LARGE_TYPES_PASSED_BY_VALUE,
+    pedantic,
+    "functions taking large arguments by value"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for functions taking arguments by reference, where
@@ -68,38 +101,10 @@ declare_clippy_lint! {
     "functions taking small copyable arguments by reference"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for functions taking arguments by value, where
-    /// the argument type is `Copy` and large enough to be worth considering
-    /// passing by reference. Does not trigger if the function is being exported,
-    /// because that might induce API breakage, if the parameter is declared as mutable,
-    /// or if the argument is a `self`.
-    ///
-    /// ### Why is this bad?
-    /// Arguments passed by value might result in an unnecessary
-    /// shallow copy, taking up more space in the stack and requiring a call to
-    /// `memcpy`, which can be expensive.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[derive(Clone, Copy)]
-    /// struct TooLarge([u8; 2048]);
-    ///
-    /// fn foo(v: TooLarge) {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # #[derive(Clone, Copy)]
-    /// # struct TooLarge([u8; 2048]);
-    /// fn foo(v: &TooLarge) {}
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub LARGE_TYPES_PASSED_BY_VALUE,
-    pedantic,
-    "functions taking large arguments by value"
-}
+impl_lint_pass!(PassByRefOrValue => [
+    LARGE_TYPES_PASSED_BY_VALUE,
+    TRIVIALLY_COPY_PASS_BY_REF,
+]);
 
 pub struct PassByRefOrValue {
     ref_min_size: u64,
@@ -237,8 +242,6 @@ impl PassByRefOrValue {
     }
 }
 
-impl_lint_pass!(PassByRefOrValue => [TRIVIALLY_COPY_PASS_BY_REF, LARGE_TYPES_PASSED_BY_VALUE]);
-
 impl<'tcx> LateLintPass<'tcx> for PassByRefOrValue {
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
         if item.span.from_expansion() {
diff --git a/clippy_lints/src/permissions_set_readonly_false.rs b/clippy_lints/src/permissions_set_readonly_false.rs
index 68a34d459e0d..a888ee546294 100644
--- a/clippy_lints/src/permissions_set_readonly_false.rs
+++ b/clippy_lints/src/permissions_set_readonly_false.rs
@@ -26,7 +26,10 @@ declare_clippy_lint! {
     suspicious,
     "Checks for calls to `std::fs::Permissions.set_readonly` with argument `false`"
 }
-declare_lint_pass!(PermissionsSetReadonlyFalse => [PERMISSIONS_SET_READONLY_FALSE]);
+
+declare_lint_pass!(PermissionsSetReadonlyFalse => [
+    PERMISSIONS_SET_READONLY_FALSE,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for PermissionsSetReadonlyFalse {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
diff --git a/clippy_lints/src/ptr/mod.rs b/clippy_lints/src/ptr/mod.rs
index c4f40a7ffcaa..f1e422d436bd 100644
--- a/clippy_lints/src/ptr/mod.rs
+++ b/clippy_lints/src/ptr/mod.rs
@@ -7,42 +7,6 @@ mod mut_from_ref;
 mod ptr_arg;
 mod ptr_eq;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// This lint checks for function arguments of type `&String`, `&Vec`,
-    /// `&PathBuf`, and `Cow<_>`. It will also suggest you replace `.clone()` calls
-    /// with the appropriate `.to_owned()`/`to_string()` calls.
-    ///
-    /// ### Why is this bad?
-    /// Requiring the argument to be of the specific type
-    /// makes the function less useful for no benefit; slices in the form of `&[T]`
-    /// or `&str` usually suffice and can be obtained from other types, too.
-    ///
-    /// ### Known problems
-    /// There may be `fn(&Vec)`-typed references pointing to your function.
-    /// If you have them, you will get a compiler error after applying this lint's
-    /// suggestions. You then have the choice to undo your changes or change the
-    /// type of the reference.
-    ///
-    /// Note that if the function is part of your public interface, there may be
-    /// other crates referencing it, of which you may not be aware. Carefully
-    /// deprecate the function before applying the lint suggestions in this case.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// fn foo(&Vec<u32>) { .. }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```ignore
-    /// fn foo(&[u32]) { .. }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub PTR_ARG,
-    style,
-    "fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` instead, respectively"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// This lint checks for equality comparisons with `ptr::null` or `ptr::null_mut`
@@ -106,6 +70,42 @@ declare_clippy_lint! {
     "fns that create mutable refs from immutable ref args"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// This lint checks for function arguments of type `&String`, `&Vec`,
+    /// `&PathBuf`, and `Cow<_>`. It will also suggest you replace `.clone()` calls
+    /// with the appropriate `.to_owned()`/`to_string()` calls.
+    ///
+    /// ### Why is this bad?
+    /// Requiring the argument to be of the specific type
+    /// makes the function less useful for no benefit; slices in the form of `&[T]`
+    /// or `&str` usually suffice and can be obtained from other types, too.
+    ///
+    /// ### Known problems
+    /// There may be `fn(&Vec)`-typed references pointing to your function.
+    /// If you have them, you will get a compiler error after applying this lint's
+    /// suggestions. You then have the choice to undo your changes or change the
+    /// type of the reference.
+    ///
+    /// Note that if the function is part of your public interface, there may be
+    /// other crates referencing it, of which you may not be aware. Carefully
+    /// deprecate the function before applying the lint suggestions in this case.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// fn foo(&Vec<u32>) { .. }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```ignore
+    /// fn foo(&[u32]) { .. }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub PTR_ARG,
+    style,
+    "fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` instead, respectively"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Use `std::ptr::eq` when applicable
@@ -135,7 +135,7 @@ declare_clippy_lint! {
     "use `std::ptr::eq` when comparing raw pointers"
 }
 
-declare_lint_pass!(Ptr => [PTR_ARG, CMP_NULL, MUT_FROM_REF, PTR_EQ]);
+declare_lint_pass!(Ptr => [CMP_NULL, MUT_FROM_REF, PTR_ARG, PTR_EQ]);
 
 impl<'tcx> LateLintPass<'tcx> for Ptr {
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
diff --git a/clippy_lints/src/pub_underscore_fields.rs b/clippy_lints/src/pub_underscore_fields.rs
index 694d44d70856..64724f7d01d0 100644
--- a/clippy_lints/src/pub_underscore_fields.rs
+++ b/clippy_lints/src/pub_underscore_fields.rs
@@ -42,11 +42,11 @@ declare_clippy_lint! {
     "struct field prefixed with underscore and marked public"
 }
 
+impl_lint_pass!(PubUnderscoreFields => [PUB_UNDERSCORE_FIELDS]);
+
 pub struct PubUnderscoreFields {
     behavior: PubUnderscoreFieldsBehaviour,
 }
-impl_lint_pass!(PubUnderscoreFields => [PUB_UNDERSCORE_FIELDS]);
-
 impl PubUnderscoreFields {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/pub_use.rs b/clippy_lints/src/pub_use.rs
index 5b973a79eae3..f3d6ed268bda 100644
--- a/clippy_lints/src/pub_use.rs
+++ b/clippy_lints/src/pub_use.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     restriction,
     "restricts the usage of `pub use`"
 }
+
 declare_lint_pass!(PubUse => [PUB_USE]);
 
 impl EarlyLintPass for PubUse {
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 719f364357d3..e79ce91d8b32 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -51,6 +51,8 @@ declare_clippy_lint! {
     "checks for expressions that could be replaced by the `?` operator"
 }
 
+impl_lint_pass!(QuestionMark => [MANUAL_LET_ELSE, QUESTION_MARK]);
+
 pub struct QuestionMark {
     pub(crate) msrv: Msrv,
     pub(crate) matches_behaviour: MatchLintBehaviour,
@@ -65,8 +67,6 @@ pub struct QuestionMark {
     inferred_ret_closure_stack: u16,
 }
 
-impl_lint_pass!(QuestionMark => [QUESTION_MARK, MANUAL_LET_ELSE]);
-
 impl QuestionMark {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index ca0d41fca524..5180281b6032 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -20,34 +20,51 @@ use std::cmp::Ordering;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for exclusive ranges where 1 is added to the
-    /// upper bound, e.g., `x..(y+1)`.
+    /// Checks for expressions like `x >= 3 && x < 8` that could
+    /// be more readably expressed as `(3..8).contains(x)`.
     ///
     /// ### Why is this bad?
-    /// The code is more readable with an inclusive range
-    /// like `x..=y`.
+    /// `contains` expresses the intent better and has less
+    /// failure modes (such as fencepost errors or using `||` instead of `&&`).
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // given
+    /// let x = 6;
+    ///
+    /// assert!(x >= 3 && x < 8);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    ///# let x = 6;
+    /// assert!((3..8).contains(&x));
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub MANUAL_RANGE_CONTAINS,
+    style,
+    "manually reimplementing {`Range`, `RangeInclusive`}`::contains`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for inclusive ranges where 1 is subtracted from
+    /// the upper bound, e.g., `x..=(y-1)`.
+    ///
+    /// ### Why is this bad?
+    /// The code is more readable with an exclusive range
+    /// like `x..y`.
     ///
     /// ### Limitations
     /// The lint is conservative and will trigger only when switching
-    /// from an exclusive to an inclusive range is provably safe from
+    /// from an inclusive to an exclusive range is provably safe from
     /// a typing point of view. This corresponds to situations where
     /// the range is used as an iterator, or for indexing.
     ///
-    /// ### Known problems
-    /// Will add unnecessary pair of parentheses when the
-    /// expression is not wrapped in a pair but starts with an opening parenthesis
-    /// and ends with a closing one.
-    /// I.e., `let _ = (f()+1)..(f()+1)` results in `let _ = ((f()+1)..=f())`.
-    ///
-    /// Also in many cases, inclusive ranges are still slower to run than
-    /// exclusive ranges, because they essentially add an extra branch that
-    /// LLVM may fail to hoist out of the loop.
-    ///
     /// ### Example
     /// ```no_run
     /// # let x = 0;
     /// # let y = 1;
-    /// for i in x..(y+1) {
+    /// for i in x..=(y-1) {
     ///     // ..
     /// }
     /// ```
@@ -56,36 +73,46 @@ declare_clippy_lint! {
     /// ```no_run
     /// # let x = 0;
     /// # let y = 1;
-    /// for i in x..=y {
+    /// for i in x..y {
     ///     // ..
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub RANGE_PLUS_ONE,
+    pub RANGE_MINUS_ONE,
     pedantic,
-    "`x..(y+1)` reads better as `x..=y`"
+    "`x..=(y-1)` reads better as `x..y`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for inclusive ranges where 1 is subtracted from
-    /// the upper bound, e.g., `x..=(y-1)`.
+    /// Checks for exclusive ranges where 1 is added to the
+    /// upper bound, e.g., `x..(y+1)`.
     ///
     /// ### Why is this bad?
-    /// The code is more readable with an exclusive range
-    /// like `x..y`.
+    /// The code is more readable with an inclusive range
+    /// like `x..=y`.
     ///
     /// ### Limitations
     /// The lint is conservative and will trigger only when switching
-    /// from an inclusive to an exclusive range is provably safe from
+    /// from an exclusive to an inclusive range is provably safe from
     /// a typing point of view. This corresponds to situations where
     /// the range is used as an iterator, or for indexing.
     ///
+    /// ### Known problems
+    /// Will add unnecessary pair of parentheses when the
+    /// expression is not wrapped in a pair but starts with an opening parenthesis
+    /// and ends with a closing one.
+    /// I.e., `let _ = (f()+1)..(f()+1)` results in `let _ = ((f()+1)..=f())`.
+    ///
+    /// Also in many cases, inclusive ranges are still slower to run than
+    /// exclusive ranges, because they essentially add an extra branch that
+    /// LLVM may fail to hoist out of the loop.
+    ///
     /// ### Example
     /// ```no_run
     /// # let x = 0;
     /// # let y = 1;
-    /// for i in x..=(y-1) {
+    /// for i in x..(y+1) {
     ///     // ..
     /// }
     /// ```
@@ -94,14 +121,14 @@ declare_clippy_lint! {
     /// ```no_run
     /// # let x = 0;
     /// # let y = 1;
-    /// for i in x..y {
+    /// for i in x..=y {
     ///     // ..
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub RANGE_MINUS_ONE,
+    pub RANGE_PLUS_ONE,
     pedantic,
-    "`x..=(y-1)` reads better as `x..y`"
+    "`x..(y+1)` reads better as `x..=y`"
 }
 
 declare_clippy_lint! {
@@ -137,32 +164,12 @@ declare_clippy_lint! {
     "reversing the limits of range expressions, resulting in empty ranges"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for expressions like `x >= 3 && x < 8` that could
-    /// be more readably expressed as `(3..8).contains(x)`.
-    ///
-    /// ### Why is this bad?
-    /// `contains` expresses the intent better and has less
-    /// failure modes (such as fencepost errors or using `||` instead of `&&`).
-    ///
-    /// ### Example
-    /// ```no_run
-    /// // given
-    /// let x = 6;
-    ///
-    /// assert!(x >= 3 && x < 8);
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    ///# let x = 6;
-    /// assert!((3..8).contains(&x));
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub MANUAL_RANGE_CONTAINS,
-    style,
-    "manually reimplementing {`Range`, `RangeInclusive`}`::contains`"
-}
+impl_lint_pass!(Ranges => [
+    MANUAL_RANGE_CONTAINS,
+    RANGE_MINUS_ONE,
+    RANGE_PLUS_ONE,
+    REVERSED_EMPTY_RANGES,
+]);
 
 pub struct Ranges {
     msrv: Msrv,
@@ -174,13 +181,6 @@ impl Ranges {
     }
 }
 
-impl_lint_pass!(Ranges => [
-    RANGE_PLUS_ONE,
-    RANGE_MINUS_ONE,
-    REVERSED_EMPTY_RANGES,
-    MANUAL_RANGE_CONTAINS,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Ranges {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Binary(ref op, l, r) = expr.kind
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index 943e662479e9..f47d5df9fb6b 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -12,48 +12,50 @@ use std::ops::ControlFlow;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for raw string literals where a string literal can be used instead.
-    ///
-    /// ### Why restrict this?
-    /// For consistent style by using simpler string literals whenever possible.
+    /// Checks for raw string literals with an unnecessary amount of hashes around them.
     ///
-    /// However, there are many cases where using a raw string literal is more
-    /// idiomatic than a string literal, so it's opt-in.
+    /// ### Why is this bad?
+    /// It's just unnecessary, and makes it look like there's more escaping needed than is actually
+    /// necessary.
     ///
     /// ### Example
     /// ```no_run
-    /// let r = r"Hello, world!";
+    /// let r = r###"Hello, "world"!"###;
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let r = "Hello, world!";
+    /// let r = r#"Hello, "world"!"#;
     /// ```
     #[clippy::version = "1.72.0"]
-    pub NEEDLESS_RAW_STRINGS,
-    restriction,
-    "suggests using a string literal when a raw string literal is unnecessary"
+    pub NEEDLESS_RAW_STRING_HASHES,
+    pedantic,
+    "suggests reducing the number of hashes around a raw string literal"
 }
+
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for raw string literals with an unnecessary amount of hashes around them.
+    /// Checks for raw string literals where a string literal can be used instead.
     ///
-    /// ### Why is this bad?
-    /// It's just unnecessary, and makes it look like there's more escaping needed than is actually
-    /// necessary.
+    /// ### Why restrict this?
+    /// For consistent style by using simpler string literals whenever possible.
+    ///
+    /// However, there are many cases where using a raw string literal is more
+    /// idiomatic than a string literal, so it's opt-in.
     ///
     /// ### Example
     /// ```no_run
-    /// let r = r###"Hello, "world"!"###;
+    /// let r = r"Hello, world!";
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let r = r#"Hello, "world"!"#;
+    /// let r = "Hello, world!";
     /// ```
     #[clippy::version = "1.72.0"]
-    pub NEEDLESS_RAW_STRING_HASHES,
-    pedantic,
-    "suggests reducing the number of hashes around a raw string literal"
+    pub NEEDLESS_RAW_STRINGS,
+    restriction,
+    "suggests using a string literal when a raw string literal is unnecessary"
 }
+
 impl_lint_pass!(RawStrings => [NEEDLESS_RAW_STRINGS, NEEDLESS_RAW_STRING_HASHES]);
 
 pub struct RawStrings {
diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index 689a2ac4c6ae..e3f718cb2d7d 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -45,6 +45,7 @@ declare_clippy_lint! {
     suspicious,
     "initializing reference-counted pointer in `vec![elem; len]`"
 }
+
 declare_lint_pass!(RcCloneInVecInit => [RC_CLONE_IN_VEC_INIT]);
 
 impl LateLintPass<'_> for RcCloneInVecInit {
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index b8d4e7c4651d..6d8b26d93f83 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -46,6 +46,7 @@ declare_clippy_lint! {
     nursery,
     "checks for reads into a zero-length `Vec`"
 }
+
 declare_lint_pass!(ReadZeroByteVec => [READ_ZERO_BYTE_VEC]);
 
 impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index d2442ad0f373..386bf3cf90fd 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     complexity,
     "`async { future.await }` can be replaced by `future`"
 }
+
 declare_lint_pass!(RedundantAsyncBlock => [REDUNDANT_ASYNC_BLOCK]);
 
 impl<'tcx> LateLintPass<'tcx> for RedundantAsyncBlock {
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index feefe10f57d7..10793ccca97f 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -35,6 +35,8 @@ declare_clippy_lint! {
     "checks for fields in struct literals where shorthands could be used"
 }
 
+impl_lint_pass!(RedundantFieldNames => [REDUNDANT_FIELD_NAMES]);
+
 pub struct RedundantFieldNames {
     msrv: MsrvStack,
 }
@@ -47,8 +49,6 @@ impl RedundantFieldNames {
     }
 }
 
-impl_lint_pass!(RedundantFieldNames => [REDUNDANT_FIELD_NAMES]);
-
 impl EarlyLintPass for RedundantFieldNames {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if !self.msrv.meets(msrvs::FIELD_INIT_SHORTHAND) {
diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index 8f33a47e2908..13bd05511ec3 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -43,6 +43,7 @@ declare_clippy_lint! {
     suspicious,
     "redundant redefinition of a local binding"
 }
+
 declare_lint_pass!(RedundantLocals => [REDUNDANT_LOCALS]);
 
 impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index 0c1c664f1117..7ebf7ccb7571 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -36,13 +36,13 @@ declare_clippy_lint! {
     "Using `pub(crate)` visibility on items that are not crate visible due to the visibility of the module that contains them."
 }
 
+impl_lint_pass!(RedundantPubCrate => [REDUNDANT_PUB_CRATE]);
+
 #[derive(Default)]
 pub struct RedundantPubCrate {
     is_exported: Vec<bool>,
 }
 
-impl_lint_pass!(RedundantPubCrate => [REDUNDANT_PUB_CRATE]);
-
 impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if cx.tcx.visibility(item.owner_id.def_id) == ty::Visibility::Restricted(CRATE_DEF_ID.to_def_id())
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index f2cf809d6012..1637156d7c37 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -11,6 +11,30 @@ use rustc_middle::ty::adjustment::{Adjust, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{GenericArg, Ty};
 use rustc_session::declare_lint_pass;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for slicing expressions which are equivalent to dereferencing the
+    /// value.
+    ///
+    /// ### Why restrict this?
+    /// Some people may prefer to dereference rather than slice.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vec = vec![1, 2, 3];
+    /// let slice = &vec[..];
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let vec = vec![1, 2, 3];
+    /// let slice = &*vec;
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub DEREF_BY_SLICING,
+    restriction,
+    "slicing instead of dereferencing"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for redundant slicing expressions which use the full range, and
@@ -42,31 +66,7 @@ declare_clippy_lint! {
     "redundant slicing of the whole range of a type"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for slicing expressions which are equivalent to dereferencing the
-    /// value.
-    ///
-    /// ### Why restrict this?
-    /// Some people may prefer to dereference rather than slice.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let vec = vec![1, 2, 3];
-    /// let slice = &vec[..];
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let vec = vec![1, 2, 3];
-    /// let slice = &*vec;
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub DEREF_BY_SLICING,
-    restriction,
-    "slicing instead of dereferencing"
-}
-
-declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING, DEREF_BY_SLICING]);
+declare_lint_pass!(RedundantSlicing => [DEREF_BY_SLICING, REDUNDANT_SLICING]);
 
 static REDUNDANT_SLICING_LINT: (&Lint, &str) = (REDUNDANT_SLICING, "redundant slicing of the whole range");
 static DEREF_BY_SLICING_LINT: (&Lint, &str) = (DEREF_BY_SLICING, "slicing when dereferencing would work");
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index da85125730a8..35cfc37b133b 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -34,6 +34,8 @@ declare_clippy_lint! {
     "Using explicit `'static` lifetime for constants or statics when elision rules would allow omitting them."
 }
 
+impl_lint_pass!(RedundantStaticLifetimes => [REDUNDANT_STATIC_LIFETIMES]);
+
 pub struct RedundantStaticLifetimes {
     msrv: MsrvStack,
 }
@@ -46,8 +48,6 @@ impl RedundantStaticLifetimes {
     }
 }
 
-impl_lint_pass!(RedundantStaticLifetimes => [REDUNDANT_STATIC_LIFETIMES]);
-
 impl RedundantStaticLifetimes {
     // Recursively visit types
     fn visit_type(ty: &Ty, cx: &EarlyContext<'_>, reason: &'static str) {
diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index e298fa55a2b6..3ffb00e2ee9d 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     restriction,
     "warns about needless / redundant type annotations."
 }
+
 declare_lint_pass!(RedundantTypeAnnotations => [REDUNDANT_TYPE_ANNOTATIONS]);
 
 fn is_same_type<'tcx>(cx: &LateContext<'tcx>, ty_resolved_path: hir::def::Res, func_return_type: Ty<'tcx>) -> bool {
diff --git a/clippy_lints/src/ref_patterns.rs b/clippy_lints/src/ref_patterns.rs
index 002c6c41d52b..b6a28571230a 100644
--- a/clippy_lints/src/ref_patterns.rs
+++ b/clippy_lints/src/ref_patterns.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     restriction,
     "use of a ref pattern, e.g. Some(ref value)"
 }
+
 declare_lint_pass!(RefPatterns => [REF_PATTERNS]);
 
 impl EarlyLintPass for RefPatterns {
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index d1fc228f4b35..80696f0a81b1 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -37,36 +37,6 @@ declare_clippy_lint! {
     "invalid regular expressions"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for trivial [regex](https://crates.io/crates/regex)
-    /// creation (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`).
-    ///
-    /// ### Why is this bad?
-    /// Matching the regex can likely be replaced by `==` or
-    /// `str::starts_with`, `str::ends_with` or `std::contains` or other `str`
-    /// methods.
-    ///
-    /// ### Known problems
-    /// If the same regex is going to be applied to multiple
-    /// inputs, the precomputations done by `Regex` construction can give
-    /// significantly better performance than any of the `str`-based methods.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// Regex::new("^foobar")
-    /// ```
-    ///
-    /// Use instead:
-    /// ```ignore
-    /// str::starts_with("foobar")
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TRIVIAL_REGEX,
-    nursery,
-    "trivial regular expressions"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     ///
@@ -105,6 +75,38 @@ declare_clippy_lint! {
     "regular expression compilation performed in a loop"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for trivial [regex](https://crates.io/crates/regex)
+    /// creation (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`).
+    ///
+    /// ### Why is this bad?
+    /// Matching the regex can likely be replaced by `==` or
+    /// `str::starts_with`, `str::ends_with` or `std::contains` or other `str`
+    /// methods.
+    ///
+    /// ### Known problems
+    /// If the same regex is going to be applied to multiple
+    /// inputs, the precomputations done by `Regex` construction can give
+    /// significantly better performance than any of the `str`-based methods.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// Regex::new("^foobar")
+    /// ```
+    ///
+    /// Use instead:
+    /// ```ignore
+    /// str::starts_with("foobar")
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub TRIVIAL_REGEX,
+    nursery,
+    "trivial regular expressions"
+}
+
+impl_lint_pass!(Regex => [INVALID_REGEX, REGEX_CREATION_IN_LOOPS, TRIVIAL_REGEX]);
+
 #[derive(Copy, Clone)]
 enum RegexKind {
     Unicode,
@@ -119,8 +121,6 @@ pub struct Regex {
     loop_stack: Vec<(OwnerId, Span)>,
 }
 
-impl_lint_pass!(Regex => [INVALID_REGEX, TRIVIAL_REGEX, REGEX_CREATION_IN_LOOPS]);
-
 impl<'tcx> LateLintPass<'tcx> for Regex {
     fn check_crate(&mut self, cx: &LateContext<'tcx>) {
         let mut resolve = |path: &PathLookup, kind: RegexKind| {
diff --git a/clippy_lints/src/replace_box.rs b/clippy_lints/src/replace_box.rs
index 638f6dc1532b..7b743746df2c 100644
--- a/clippy_lints/src/replace_box.rs
+++ b/clippy_lints/src/replace_box.rs
@@ -40,6 +40,8 @@ declare_clippy_lint! {
     "assigning a newly created box to `Box<T>` is inefficient"
 }
 
+impl_lint_pass!(ReplaceBox => [REPLACE_BOX]);
+
 #[derive(Default)]
 pub struct ReplaceBox {
     consumed_locals: FxHashSet<HirId>,
@@ -67,8 +69,6 @@ impl ReplaceBox {
     }
 }
 
-impl_lint_pass!(ReplaceBox => [REPLACE_BOX]);
-
 impl LateLintPass<'_> for ReplaceBox {
     fn check_body_post(&mut self, _: &LateContext<'_>, body: &Body<'_>) {
         if self.loaded_bodies.first().is_some_and(|&x| x == body.id()) {
diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index ce86a9caac75..b5503f6cdfb0 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -31,6 +31,7 @@ declare_clippy_lint! {
     complexity,
     "`reserve` called immediately after `Vec` creation"
 }
+
 impl_lint_pass!(ReserveAfterInitialization => [RESERVE_AFTER_INITIALIZATION]);
 
 #[derive(Default)]
diff --git a/clippy_lints/src/returns/mod.rs b/clippy_lints/src/returns/mod.rs
index 47c6332b9b81..eb84582593a4 100644
--- a/clippy_lints/src/returns/mod.rs
+++ b/clippy_lints/src/returns/mod.rs
@@ -115,7 +115,11 @@ declare_clippy_lint! {
     "using a return statement like `return Err(expr)?;` where removing it would suffice"
 }
 
-declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN, NEEDLESS_RETURN_WITH_QUESTION_MARK]);
+declare_lint_pass!(Return => [
+    LET_AND_RETURN,
+    NEEDLESS_RETURN,
+    NEEDLESS_RETURN_WITH_QUESTION_MARK,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for Return {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
diff --git a/clippy_lints/src/same_length_and_capacity.rs b/clippy_lints/src/same_length_and_capacity.rs
index 042dec35f7c9..b200fd1fe25f 100644
--- a/clippy_lints/src/same_length_and_capacity.rs
+++ b/clippy_lints/src/same_length_and_capacity.rs
@@ -70,6 +70,7 @@ declare_clippy_lint! {
     pedantic,
     "`from_raw_parts` with same length and capacity"
 }
+
 declare_lint_pass!(SameLengthAndCapacity => [SAME_LENGTH_AND_CAPACITY]);
 
 impl<'tcx> LateLintPass<'tcx> for SameLengthAndCapacity {
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 371d62a06849..7c68762b22c0 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     restriction,
     "add a semicolon inside the block"
 }
+
 declare_clippy_lint! {
     /// ### What it does
     ///
@@ -64,6 +65,7 @@ declare_clippy_lint! {
     restriction,
     "add a semicolon outside the block"
 }
+
 impl_lint_pass!(SemicolonBlock => [SEMICOLON_INSIDE_BLOCK, SEMICOLON_OUTSIDE_BLOCK]);
 
 pub struct SemicolonBlock {
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index f6083394fea5..4fa22ff0cdb5 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -18,56 +18,56 @@ use rustc_span::{Span, Symbol};
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for bindings that shadow other bindings already in
-    /// scope, while just changing reference level or mutability.
+    /// scope, while reusing the original value.
     ///
     /// ### Why restrict this?
-    /// To require that what are formally distinct variables be given distinct names.
+    /// Some argue that name shadowing like this hurts readability,
+    /// because a value may be bound to different things depending on position in
+    /// the code.
     ///
-    /// See also `shadow_reuse` and `shadow_unrelated` for other restrictions on shadowing.
+    /// See also `shadow_same` and `shadow_unrelated` for other restrictions on shadowing.
     ///
     /// ### Example
     /// ```no_run
-    /// # let x = 1;
-    /// let x = &x;
+    /// let x = 2;
+    /// let x = x + 1;
     /// ```
-    ///
-    /// Use instead:
+    /// use different variable name:
     /// ```no_run
-    /// # let x = 1;
-    /// let y = &x; // use different variable name
+    /// let x = 2;
+    /// let y = x + 1;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub SHADOW_SAME,
+    pub SHADOW_REUSE,
     restriction,
-    "rebinding a name to itself, e.g., `let mut x = &mut x`"
+    "rebinding a name to an expression that reuses the original value, e.g., `let x = x + 1`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for bindings that shadow other bindings already in
-    /// scope, while reusing the original value.
+    /// scope, while just changing reference level or mutability.
     ///
     /// ### Why restrict this?
-    /// Some argue that name shadowing like this hurts readability,
-    /// because a value may be bound to different things depending on position in
-    /// the code.
+    /// To require that what are formally distinct variables be given distinct names.
     ///
-    /// See also `shadow_same` and `shadow_unrelated` for other restrictions on shadowing.
+    /// See also `shadow_reuse` and `shadow_unrelated` for other restrictions on shadowing.
     ///
     /// ### Example
     /// ```no_run
-    /// let x = 2;
-    /// let x = x + 1;
+    /// # let x = 1;
+    /// let x = &x;
     /// ```
-    /// use different variable name:
+    ///
+    /// Use instead:
     /// ```no_run
-    /// let x = 2;
-    /// let y = x + 1;
+    /// # let x = 1;
+    /// let y = &x; // use different variable name
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub SHADOW_REUSE,
+    pub SHADOW_SAME,
     restriction,
-    "rebinding a name to an expression that reuses the original value, e.g., `let x = x + 1`"
+    "rebinding a name to itself, e.g., `let mut x = &mut x`"
 }
 
 declare_clippy_lint! {
@@ -106,13 +106,13 @@ declare_clippy_lint! {
     "rebinding a name without even using the original value"
 }
 
+impl_lint_pass!(Shadow => [SHADOW_REUSE, SHADOW_SAME, SHADOW_UNRELATED]);
+
 #[derive(Default)]
 pub(crate) struct Shadow {
     bindings: Vec<(FxHashMap<Symbol, Vec<ItemLocalId>>, LocalDefId)>,
 }
 
-impl_lint_pass!(Shadow => [SHADOW_SAME, SHADOW_REUSE, SHADOW_UNRELATED]);
-
 impl<'tcx> LateLintPass<'tcx> for Shadow {
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
         let PatKind::Binding(_, id, ident, _) = pat.kind else {
diff --git a/clippy_lints/src/single_call_fn.rs b/clippy_lints/src/single_call_fn.rs
index 64891743dc63..4adcc1cac123 100644
--- a/clippy_lints/src/single_call_fn.rs
+++ b/clippy_lints/src/single_call_fn.rs
@@ -58,6 +58,7 @@ declare_clippy_lint! {
     restriction,
     "checks for functions that are only used once"
 }
+
 impl_lint_pass!(SingleCallFn => [SINGLE_CALL_FN]);
 
 #[derive(Debug, Clone)]
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 07a8eb5d886c..36ea341a87bc 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -37,6 +37,8 @@ declare_clippy_lint! {
     "imports with single component path are redundant"
 }
 
+impl_lint_pass!(SingleComponentPathImports => [SINGLE_COMPONENT_PATH_IMPORTS]);
+
 #[derive(Default)]
 pub struct SingleComponentPathImports {
     /// Buffer found usages to emit when visiting that item so that `#[allow]` works as expected
@@ -50,8 +52,6 @@ struct SingleUse {
     can_suggest: bool,
 }
 
-impl_lint_pass!(SingleComponentPathImports => [SINGLE_COMPONENT_PATH_IMPORTS]);
-
 impl EarlyLintPass for SingleComponentPathImports {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
         if cx.sess().opts.edition < Edition::Edition2018 {
diff --git a/clippy_lints/src/single_range_in_vec_init.rs b/clippy_lints/src/single_range_in_vec_init.rs
index e4906eb0c777..a9e90dec5dc9 100644
--- a/clippy_lints/src/single_range_in_vec_init.rs
+++ b/clippy_lints/src/single_range_in_vec_init.rs
@@ -37,6 +37,7 @@ declare_clippy_lint! {
     suspicious,
     "checks for initialization of `Vec` or arrays which consist of a single range"
 }
+
 declare_lint_pass!(SingleRangeInVecInit => [SINGLE_RANGE_IN_VEC_INIT]);
 
 enum SuggestedType {
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
index bf304ebcfdc0..3df4c4e5298f 100644
--- a/clippy_lints/src/size_of_ref.rs
+++ b/clippy_lints/src/size_of_ref.rs
@@ -52,6 +52,7 @@ declare_clippy_lint! {
     suspicious,
     "Argument to `size_of_val()` is a double-reference, which is almost certainly unintended"
 }
+
 declare_lint_pass!(SizeOfRef => [SIZE_OF_REF]);
 
 impl LateLintPass<'_> for SizeOfRef {
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index 143be5137038..d519afba61b5 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -13,25 +13,30 @@ use rustc_span::{Span, sym};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds items imported through `std` when available through `core`.
+    /// Finds items imported through `alloc` when available through `core`.
     ///
     /// ### Why restrict this?
-    /// Crates which have `no_std` compatibility may wish to ensure types are imported from core to ensure
-    /// disabling `std` does not cause the crate to fail to compile. This lint is also useful for crates
-    /// migrating to become `no_std` compatible.
+    /// Crates which have `no_std` compatibility and may optionally require alloc may wish to ensure types are
+    /// imported from core to ensure disabling `alloc` does not cause the crate to fail to compile. This lint
+    /// is also useful for crates migrating to become `no_std` compatible.
+    ///
+    /// ### Known problems
+    /// The lint is only partially aware of the required MSRV for items that were originally in `std` but moved
+    /// to `core`.
     ///
     /// ### Example
     /// ```no_run
-    /// use std::hash::Hasher;
+    /// # extern crate alloc;
+    /// use alloc::slice::from_ref;
     /// ```
     /// Use instead:
     /// ```no_run
-    /// use core::hash::Hasher;
+    /// use core::slice::from_ref;
     /// ```
     #[clippy::version = "1.64.0"]
-    pub STD_INSTEAD_OF_CORE,
+    pub ALLOC_INSTEAD_OF_CORE,
     restriction,
-    "type is imported from std when available in core"
+    "type is imported from alloc when available in core"
 }
 
 declare_clippy_lint! {
@@ -60,32 +65,33 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds items imported through `alloc` when available through `core`.
+    /// Finds items imported through `std` when available through `core`.
     ///
     /// ### Why restrict this?
-    /// Crates which have `no_std` compatibility and may optionally require alloc may wish to ensure types are
-    /// imported from core to ensure disabling `alloc` does not cause the crate to fail to compile. This lint
-    /// is also useful for crates migrating to become `no_std` compatible.
-    ///
-    /// ### Known problems
-    /// The lint is only partially aware of the required MSRV for items that were originally in `std` but moved
-    /// to `core`.
+    /// Crates which have `no_std` compatibility may wish to ensure types are imported from core to ensure
+    /// disabling `std` does not cause the crate to fail to compile. This lint is also useful for crates
+    /// migrating to become `no_std` compatible.
     ///
     /// ### Example
     /// ```no_run
-    /// # extern crate alloc;
-    /// use alloc::slice::from_ref;
+    /// use std::hash::Hasher;
     /// ```
     /// Use instead:
     /// ```no_run
-    /// use core::slice::from_ref;
+    /// use core::hash::Hasher;
     /// ```
     #[clippy::version = "1.64.0"]
-    pub ALLOC_INSTEAD_OF_CORE,
+    pub STD_INSTEAD_OF_CORE,
     restriction,
-    "type is imported from alloc when available in core"
+    "type is imported from std when available in core"
 }
 
+impl_lint_pass!(StdReexports => [
+    ALLOC_INSTEAD_OF_CORE,
+    STD_INSTEAD_OF_ALLOC,
+    STD_INSTEAD_OF_CORE,
+]);
+
 pub struct StdReexports {
     lint_points: Option<(Span, Vec<LintPoint>)>,
     msrv: Msrv,
@@ -109,8 +115,6 @@ impl StdReexports {
     }
 }
 
-impl_lint_pass!(StdReexports => [STD_INSTEAD_OF_CORE, STD_INSTEAD_OF_ALLOC, ALLOC_INSTEAD_OF_CORE]);
-
 #[derive(Debug)]
 enum LintPoint {
     Available(Span, &'static Lint, &'static str, &'static str),
diff --git a/clippy_lints/src/string_patterns.rs b/clippy_lints/src/string_patterns.rs
index e5347bf3e8f0..3528fa36e2d1 100644
--- a/clippy_lints/src/string_patterns.rs
+++ b/clippy_lints/src/string_patterns.rs
@@ -72,6 +72,11 @@ declare_clippy_lint! {
     "using a single-character str where a char could be used, e.g., `_.split(\"x\")`"
 }
 
+impl_lint_pass!(StringPatterns => [
+    MANUAL_PATTERN_CHAR_COMPARISON,
+    SINGLE_CHAR_PATTERN,
+]);
+
 pub struct StringPatterns {
     msrv: Msrv,
 }
@@ -82,8 +87,6 @@ impl StringPatterns {
     }
 }
 
-impl_lint_pass!(StringPatterns => [MANUAL_PATTERN_CHAR_COMPARISON, SINGLE_CHAR_PATTERN]);
-
 const PATTERN_METHODS: [(Symbol, usize); 22] = [
     (sym::contains, 0),
     (sym::starts_with, 0),
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 9d3e4a6b1d92..ab11c37b5041 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -15,26 +15,25 @@ use rustc_span::source_map::Spanned;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for string appends of the form `x = x + y` (without
-    /// `let`!).
+    /// This lint checks for `.to_string()` method calls on values of type `&str`.
     ///
-    /// ### Why is this bad?
-    /// It's not really bad, but some people think that the
-    /// `.push_str(_)` method is more readable.
+    /// ### Why restrict this?
+    /// The `to_string` method is also used on other types to convert them to a string.
+    /// When called on a `&str` it turns the `&str` into the owned variant `String`, which can be
+    /// more specifically expressed with `.to_owned()`.
     ///
     /// ### Example
     /// ```no_run
-    /// let mut x = "Hello".to_owned();
-    /// x = x + ", World";
-    ///
-    /// // More readable
-    /// x += ", World";
-    /// x.push_str(", World");
+    /// let _ = "str".to_string();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let _ = "str".to_owned();
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub STRING_ADD_ASSIGN,
-    pedantic,
-    "using `x = x + ..` where x is a `String` instead of `push_str()`"
+    pub STR_TO_STRING,
+    restriction,
+    "using `to_string()` on a `&str`, which should be `to_owned()`"
 }
 
 declare_clippy_lint! {
@@ -71,6 +70,52 @@ declare_clippy_lint! {
     "using `x + ..` where x is a `String` instead of `push_str()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for string appends of the form `x = x + y` (without
+    /// `let`!).
+    ///
+    /// ### Why is this bad?
+    /// It's not really bad, but some people think that the
+    /// `.push_str(_)` method is more readable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let mut x = "Hello".to_owned();
+    /// x = x + ", World";
+    ///
+    /// // More readable
+    /// x += ", World";
+    /// x.push_str(", World");
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub STRING_ADD_ASSIGN,
+    pedantic,
+    "using `x = x + ..` where x is a `String` instead of `push_str()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check if the string is transformed to byte array and casted back to string.
+    ///
+    /// ### Why is this bad?
+    /// It's unnecessary, the string can be used directly.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// &"Hello World!"[6..11];
+    /// ```
+    #[clippy::version = "1.50.0"]
+    pub STRING_FROM_UTF8_AS_BYTES,
+    complexity,
+    "casting string slices to byte slices and back"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the `as_bytes` method called on string literals
@@ -141,8 +186,38 @@ declare_clippy_lint! {
     "slicing a string"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns about calling `str::trim` (or variants) before `str::split_whitespace`.
+    ///
+    /// ### Why is this bad?
+    /// `split_whitespace` already ignores leading and trailing whitespace.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// " A B C ".trim().split_whitespace();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// " A B C ".split_whitespace();
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub TRIM_SPLIT_WHITESPACE,
+    style,
+    "using `str::trim()` or alike before `str::split_whitespace`"
+}
+
+declare_lint_pass!(StrToString => [STR_TO_STRING]);
+
 declare_lint_pass!(StringAdd => [STRING_ADD, STRING_ADD_ASSIGN, STRING_SLICE]);
 
+declare_lint_pass!(StringLitAsBytes => [
+    STRING_FROM_UTF8_AS_BYTES,
+    STRING_LIT_AS_BYTES,
+]);
+
+declare_lint_pass!(TrimSplitWhitespace => [TRIM_SPLIT_WHITESPACE]);
+
 impl<'tcx> LateLintPass<'tcx> for StringAdd {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if e.span.in_external_macro(cx.sess().source_map()) {
@@ -218,33 +293,9 @@ fn is_add(cx: &LateContext<'_>, src: &Expr<'_>, target: &Expr<'_>) -> bool {
     }
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Check if the string is transformed to byte array and casted back to string.
-    ///
-    /// ### Why is this bad?
-    /// It's unnecessary, the string can be used directly.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// &"Hello World!"[6..11];
-    /// ```
-    #[clippy::version = "1.50.0"]
-    pub STRING_FROM_UTF8_AS_BYTES,
-    complexity,
-    "casting string slices to byte slices and back"
-}
-
 // Max length a b"foo" string can take
 const MAX_LENGTH_BYTE_STRING_LIT: usize = 32;
 
-declare_lint_pass!(StringLitAsBytes => [STRING_LIT_AS_BYTES, STRING_FROM_UTF8_AS_BYTES]);
-
 impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use rustc_ast::LitKind;
@@ -358,31 +409,6 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
     }
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// This lint checks for `.to_string()` method calls on values of type `&str`.
-    ///
-    /// ### Why restrict this?
-    /// The `to_string` method is also used on other types to convert them to a string.
-    /// When called on a `&str` it turns the `&str` into the owned variant `String`, which can be
-    /// more specifically expressed with `.to_owned()`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let _ = "str".to_string();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// let _ = "str".to_owned();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub STR_TO_STRING,
-    restriction,
-    "using `to_string()` on a `&str`, which should be `to_owned()`"
-}
-
-declare_lint_pass!(StrToString => [STR_TO_STRING]);
-
 impl<'tcx> LateLintPass<'tcx> for StrToString {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
         if expr.span.from_expansion() {
@@ -430,28 +456,6 @@ impl<'tcx> LateLintPass<'tcx> for StrToString {
     }
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns about calling `str::trim` (or variants) before `str::split_whitespace`.
-    ///
-    /// ### Why is this bad?
-    /// `split_whitespace` already ignores leading and trailing whitespace.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// " A B C ".trim().split_whitespace();
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// " A B C ".split_whitespace();
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub TRIM_SPLIT_WHITESPACE,
-    style,
-    "using `str::trim()` or alike before `str::split_whitespace`"
-}
-declare_lint_pass!(TrimSplitWhitespace => [TRIM_SPLIT_WHITESPACE]);
-
 impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
         let tyckres = cx.typeck_results();
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index 962ab9cce14c..53038672d1ec 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -37,6 +37,8 @@ declare_clippy_lint! {
     "using `libc::strlen` on a `CString` or `CStr` value, while `count_bytes()` can be used instead"
 }
 
+impl_lint_pass!(StrlenOnCStrings => [STRLEN_ON_C_STRINGS]);
+
 pub struct StrlenOnCStrings {
     msrv: Msrv,
 }
@@ -47,8 +49,6 @@ impl StrlenOnCStrings {
     }
 }
 
-impl_lint_pass!(StrlenOnCStrings => [STRLEN_ON_C_STRINGS]);
-
 impl<'tcx> LateLintPass<'tcx> for StrlenOnCStrings {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion()
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index af5e3ccb674a..9fa4d2c142b5 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -64,7 +64,9 @@ declare_clippy_lint! {
     "groupings of binary operations that look suspiciously like typos"
 }
 
-declare_lint_pass!(SuspiciousOperationGroupings => [SUSPICIOUS_OPERATION_GROUPINGS]);
+declare_lint_pass!(SuspiciousOperationGroupings => [
+    SUSPICIOUS_OPERATION_GROUPINGS,
+]);
 
 impl EarlyLintPass for SuspiciousOperationGroupings {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index edb7600b7c06..694f1896a4d2 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -53,7 +53,10 @@ declare_clippy_lint! {
     "suspicious use of operators in impl of OpAssign trait"
 }
 
-declare_lint_pass!(SuspiciousImpl => [SUSPICIOUS_ARITHMETIC_IMPL, SUSPICIOUS_OP_ASSIGN_IMPL]);
+declare_lint_pass!(SuspiciousImpl => [
+    SUSPICIOUS_ARITHMETIC_IMPL,
+    SUSPICIOUS_OP_ASSIGN_IMPL,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index e55d17818e4f..37fdba91cc02 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     restriction,
     "XOR (`^`) operator possibly used as exponentiation operator"
 }
+
 declare_lint_pass!(ConfusingXorAndPow => [SUSPICIOUS_XOR_USED_AS_POW]);
 
 impl LateLintPass<'_> for ConfusingXorAndPow {
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index c3cb2c09752f..1a1776bb3608 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -18,6 +18,32 @@ use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Ident;
 use rustc_span::{Span, SyntaxContext, sym};
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `foo = bar; bar = foo` sequences.
+    ///
+    /// ### Why is this bad?
+    /// This looks like a failed attempt to swap.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let mut a = 1;
+    /// # let mut b = 2;
+    /// a = b;
+    /// b = a;
+    /// ```
+    /// If swapping is intended, use `swap()` instead:
+    /// ```no_run
+    /// # let mut a = 1;
+    /// # let mut b = 2;
+    /// std::mem::swap(&mut a, &mut b);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ALMOST_SWAPPED,
+    correctness,
+    "`foo = bar; bar = foo` sequence"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for manual swapping.
@@ -49,33 +75,7 @@ declare_clippy_lint! {
     "manual swap of two variables"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `foo = bar; bar = foo` sequences.
-    ///
-    /// ### Why is this bad?
-    /// This looks like a failed attempt to swap.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let mut a = 1;
-    /// # let mut b = 2;
-    /// a = b;
-    /// b = a;
-    /// ```
-    /// If swapping is intended, use `swap()` instead:
-    /// ```no_run
-    /// # let mut a = 1;
-    /// # let mut b = 2;
-    /// std::mem::swap(&mut a, &mut b);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ALMOST_SWAPPED,
-    correctness,
-    "`foo = bar; bar = foo` sequence"
-}
-
-declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED]);
+declare_lint_pass!(Swap => [ALMOST_SWAPPED, MANUAL_SWAP]);
 
 impl<'tcx> LateLintPass<'tcx> for Swap {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
diff --git a/clippy_lints/src/swap_ptr_to_ref.rs b/clippy_lints/src/swap_ptr_to_ref.rs
index 339c97d575ae..4d7bb2cc1f98 100644
--- a/clippy_lints/src/swap_ptr_to_ref.rs
+++ b/clippy_lints/src/swap_ptr_to_ref.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     suspicious,
     "call to `mem::swap` using pointer derived references"
 }
+
 declare_lint_pass!(SwapPtrToRef => [SWAP_PTR_TO_REF]);
 
 impl LateLintPass<'_> for SwapPtrToRef {
diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index 8151dd8f2cfe..bc242ba73a63 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -23,12 +23,12 @@ declare_clippy_lint! {
     "assignments to temporaries"
 }
 
+declare_lint_pass!(TemporaryAssignment => [TEMPORARY_ASSIGNMENT]);
+
 fn is_temporary(expr: &Expr<'_>) -> bool {
     matches!(&expr.kind, ExprKind::Struct(..) | ExprKind::Tup(..))
 }
 
-declare_lint_pass!(TemporaryAssignment => [TEMPORARY_ASSIGNMENT]);
-
 impl<'tcx> LateLintPass<'tcx> for TemporaryAssignment {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Assign(target, ..) = &expr.kind {
diff --git a/clippy_lints/src/time_subtraction.rs b/clippy_lints/src/time_subtraction.rs
index 457a8f48f7e2..e906ee081346 100644
--- a/clippy_lints/src/time_subtraction.rs
+++ b/clippy_lints/src/time_subtraction.rs
@@ -73,6 +73,11 @@ declare_clippy_lint! {
     "finds unchecked subtraction involving 'Duration' or 'Instant'"
 }
 
+impl_lint_pass!(UncheckedTimeSubtraction => [
+    MANUAL_INSTANT_ELAPSED,
+    UNCHECKED_TIME_SUBTRACTION,
+]);
+
 pub struct UncheckedTimeSubtraction {
     msrv: Msrv,
 }
@@ -83,8 +88,6 @@ impl UncheckedTimeSubtraction {
     }
 }
 
-impl_lint_pass!(UncheckedTimeSubtraction => [MANUAL_INSTANT_ELAPSED, UNCHECKED_TIME_SUBTRACTION]);
-
 impl LateLintPass<'_> for UncheckedTimeSubtraction {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         let (lhs, rhs) = match expr.kind {
diff --git a/clippy_lints/src/trailing_empty_array.rs b/clippy_lints/src/trailing_empty_array.rs
index 75a82770af04..8bac517682db 100644
--- a/clippy_lints/src/trailing_empty_array.rs
+++ b/clippy_lints/src/trailing_empty_array.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     nursery,
     "struct with a trailing zero-sized array but without `#[repr(C)]` or another `repr` attribute"
 }
+
 declare_lint_pass!(TrailingEmptyArray => [TRAILING_EMPTY_ARRAY]);
 
 impl<'tcx> LateLintPass<'tcx> for TrailingEmptyArray {
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 352b8526b021..62074c7052e2 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -17,29 +17,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// This lint warns about unnecessary type repetitions in trait bounds
-    ///
-    /// ### Why is this bad?
-    /// Repeating the type for every bound makes the code
-    /// less readable than combining the bounds
-    ///
-    /// ### Example
-    /// ```no_run
-    /// pub fn foo<T>(t: T) where T: Copy, T: Clone {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// pub fn foo<T>(t: T) where T: Copy + Clone {}
-    /// ```
-    #[clippy::version = "1.38.0"]
-    pub TYPE_REPETITION_IN_BOUNDS,
-    nursery,
-    "types are repeated unnecessarily in trait bounds, use `+` instead of using `T: _, T: _`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for cases where generics or trait objects are being used and multiple
@@ -86,6 +63,34 @@ declare_clippy_lint! {
     "check if the same trait bounds are specified more than once during a generic declaration"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// This lint warns about unnecessary type repetitions in trait bounds
+    ///
+    /// ### Why is this bad?
+    /// Repeating the type for every bound makes the code
+    /// less readable than combining the bounds
+    ///
+    /// ### Example
+    /// ```no_run
+    /// pub fn foo<T>(t: T) where T: Copy, T: Clone {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// pub fn foo<T>(t: T) where T: Copy + Clone {}
+    /// ```
+    #[clippy::version = "1.38.0"]
+    pub TYPE_REPETITION_IN_BOUNDS,
+    nursery,
+    "types are repeated unnecessarily in trait bounds, use `+` instead of using `T: _, T: _`"
+}
+
+impl_lint_pass!(TraitBounds => [
+    TRAIT_DUPLICATION_IN_BOUNDS,
+    TYPE_REPETITION_IN_BOUNDS,
+]);
+
 pub struct TraitBounds {
     max_trait_bounds: u64,
     msrv: Msrv,
@@ -100,8 +105,6 @@ impl TraitBounds {
     }
 }
 
-impl_lint_pass!(TraitBounds => [TYPE_REPETITION_IN_BOUNDS, TRAIT_DUPLICATION_IN_BOUNDS]);
-
 impl<'tcx> LateLintPass<'tcx> for TraitBounds {
     fn check_generics(&mut self, cx: &LateContext<'tcx>, generics: &'tcx Generics<'_>) {
         self.check_type_repetition(cx, generics);
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 435cd7bcba4e..625388782e8d 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -28,116 +28,129 @@ use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for transmutes that can't ever be correct on any
-    /// architecture.
-    ///
-    /// ### Why is this bad?
-    /// It's basically guaranteed to be undefined behavior.
-    ///
-    /// ### Known problems
-    /// When accessing C, users might want to store pointer
-    /// sized objects in `extradata` arguments to save an allocation.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// let ptr: *const T = core::intrinsics::transmute('x')
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub WRONG_TRANSMUTE,
-    correctness,
-    "transmutes that are confusing at best, undefined behavior at worst and always useless"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes to the original type of the object
-    /// and transmutes that could be a cast.
+    /// Checks for transmutes between a type `T` and `*T`.
     ///
     /// ### Why is this bad?
-    /// Readability. The code tricks people into thinking that
-    /// something complex is going on.
+    /// It's easy to mistakenly transmute between a type and a
+    /// pointer to that type.
     ///
     /// ### Example
     /// ```rust,ignore
-    /// core::intrinsics::transmute(t); // where the result type is the same as `t`'s
+    /// core::intrinsics::transmute(t) // where the result type is the same as
+    ///                                // `*t` or `&t`'s
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub USELESS_TRANSMUTE,
-    complexity,
-    "transmutes that have the same to and from types or could be a cast/coercion"
+    pub CROSSPOINTER_TRANSMUTE,
+    suspicious,
+    "transmutes that have to or from types that are a pointer to the other"
 }
 
-// FIXME: Merge this lint with USELESS_TRANSMUTE once that is out of the nursery.
 declare_clippy_lint! {
     /// ### What it does
-    ///Checks for transmutes that could be a pointer cast.
+    /// Checks for integer validity checks, followed by a transmute that is (incorrectly) evaluated
+    /// eagerly (e.g. using `bool::then_some`).
     ///
     /// ### Why is this bad?
-    /// Readability. The code tricks people into thinking that
-    /// something complex is going on.
+    /// Eager evaluation means that the `transmute` call is executed regardless of whether the condition is true or false.
+    /// This can introduce unsoundness and other subtle bugs.
     ///
     /// ### Example
+    /// Consider the following function which is meant to convert an unsigned integer to its enum equivalent via transmute.
     ///
     /// ```no_run
-    /// # let p: *const [i32] = &[];
-    /// unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };
+    /// #[repr(u8)]
+    /// enum Opcode {
+    ///     Add = 0,
+    ///     Sub = 1,
+    ///     Mul = 2,
+    ///     Div = 3
+    /// }
+    ///
+    /// fn int_to_opcode(op: u8) -> Option<Opcode> {
+    ///     (op < 4).then_some(unsafe { std::mem::transmute(op) })
+    /// }
     /// ```
-    /// Use instead:
-    /// ```no_run
-    /// # let p: *const [i32] = &[];
-    /// p as *const [u16];
+    /// This may appear fine at first given that it checks that the `u8` is within the validity range of the enum,
+    /// *however* the transmute is evaluated eagerly, meaning that it executes even if `op >= 4`!
+    ///
+    /// This makes the function unsound, because it is possible for the caller to cause undefined behavior
+    /// (creating an enum with an invalid bitpattern) entirely in safe code only by passing an incorrect value,
+    /// which is normally only a bug that is possible in unsafe code.
+    ///
+    /// One possible way in which this can go wrong practically is that the compiler sees it as:
+    /// ```rust,ignore (illustrative)
+    /// let temp: Foo = unsafe { std::mem::transmute(op) };
+    /// (0 < 4).then_some(temp)
     /// ```
-    #[clippy::version = "1.47.0"]
-    pub TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-    complexity,
-    "transmutes that could be a pointer cast"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmutes between a type `T` and `*T`.
+    /// and optimizes away the `(0 < 4)` check based on the assumption that since a `Foo` was created from `op` with the validity range `0..3`,
+    /// it is **impossible** for this condition to be false.
     ///
-    /// ### Why is this bad?
-    /// It's easy to mistakenly transmute between a type and a
-    /// pointer to that type.
+    /// In short, it is possible for this function to be optimized in a way that makes it [never return `None`](https://godbolt.org/z/ocrcenevq),
+    /// even if passed the value `4`.
     ///
-    /// ### Example
-    /// ```rust,ignore
-    /// core::intrinsics::transmute(t) // where the result type is the same as
-    ///                                // `*t` or `&t`'s
+    /// This can be avoided by instead using lazy evaluation. For the example above, this should be written:
+    /// ```rust,ignore (illustrative)
+    /// fn int_to_opcode(op: u8) -> Option<Opcode> {
+    ///     (op < 4).then(|| unsafe { std::mem::transmute(op) })
+    ///              ^^^^ ^^ `bool::then` only executes the closure if the condition is true!
+    /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub CROSSPOINTER_TRANSMUTE,
-    suspicious,
-    "transmutes that have to or from types that are a pointer to the other"
+    #[clippy::version = "1.77.0"]
+    pub EAGER_TRANSMUTE,
+    correctness,
+    "eager evaluation of `transmute`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for transmutes from a pointer to a reference.
+    /// Checks if transmute calls have all generics specified.
     ///
     /// ### Why is this bad?
-    /// This can always be rewritten with `&` and `*`.
+    /// If not, one or more unexpected types could be used during `transmute()`, potentially leading
+    /// to Undefined Behavior or other problems.
     ///
-    /// ### Known problems
-    /// - `mem::transmute` in statics and constants is stable from Rust 1.46.0,
-    /// while dereferencing raw pointer is not stable yet.
-    /// If you need to do this in those places,
-    /// you would have to use `transmute` instead.
+    /// This is particularly dangerous in case a seemingly innocent/unrelated change causes type
+    /// inference to result in a different type. For example, if `transmute()` is the tail
+    /// expression of an `if`-branch, and the `else`-branch type changes, the compiler may silently
+    /// infer a different type to be returned by `transmute()`. That is because the compiler is
+    /// free to change the inference of a type as long as that inference is technically correct,
+    /// regardless of the programmer's unknown expectation.
+    ///
+    /// Both type-parameters, the input- and the output-type, to any `transmute()` should
+    /// be given explicitly: Setting the input-type explicitly avoids confusion about what the
+    /// argument's type actually is. Setting the output-type explicitly avoids type-inference
+    /// to infer a technically correct yet unexpected type.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// unsafe {
-    ///     let _: &T = std::mem::transmute(p); // where p: *const T
-    /// }
+    /// ```
+    /// # unsafe {
+    /// let mut x: i32 = 0;
+    /// // Avoid "naked" calls to `transmute()`!
+    /// x = std::mem::transmute([1u16, 2u16]);
     ///
-    /// // can be written:
-    /// let _: &T = &*p;
+    /// // `first_answers` is intended to transmute a slice of bool to a slice of u8.
+    /// // But the programmer forgot to index the first element of the outer slice,
+    /// // so we are actually transmuting from "pointers to slices" instead of
+    /// // transmuting from "a slice of bool", causing a nonsensical result.
+    /// let the_answers: &[&[bool]] = &[&[true, false, true]];
+    /// let first_answers: &[u8] = std::mem::transmute(the_answers);
+    /// # }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TRANSMUTE_PTR_TO_REF,
-    complexity,
-    "transmutes from a pointer to a reference type"
+    /// Use instead:
+    /// ```
+    /// # unsafe {
+    /// let x = std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]);
+    ///
+    /// // The explicit type parameters on `transmute()` makes the intention clear,
+    /// // and cause a type-error if the actual types don't match our expectation.
+    /// let the_answers: &[&[bool]] = &[&[true, false, true]];
+    /// let first_answers: &[u8] = std::mem::transmute::<&[bool], &[u8]>(the_answers[0]);
+    /// # }
+    /// ```
+    #[clippy::version = "1.79.0"]
+    pub MISSING_TRANSMUTE_ANNOTATIONS,
+    suspicious,
+    "warns if a transmute call doesn't have all generics specified"
 }
 
 declare_clippy_lint! {
@@ -222,6 +235,34 @@ declare_clippy_lint! {
     "transmutes from an integer to a non-zero wrapper"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for null function pointer creation through transmute.
+    ///
+    /// ### Why is this bad?
+    /// Creating a null function pointer is undefined behavior.
+    ///
+    /// More info: https://doc.rust-lang.org/nomicon/ffi.html#the-nullable-pointer-optimization
+    ///
+    /// ### Known problems
+    /// Not all cases can be detected at the moment of this writing.
+    /// For example, variables which hold a null pointer and are then fed to a `transmute`
+    /// call, aren't detectable yet.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let null_fn: fn() = unsafe { std::mem::transmute( std::ptr::null::<()>() ) };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let null_fn: Option<fn()> = None;
+    /// ```
+    #[clippy::version = "1.68.0"]
+    pub TRANSMUTE_NULL_TO_FN,
+    correctness,
+    "transmute results in a null function pointer, which is undefined behavior"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for transmutes from a pointer to a pointer, or
@@ -252,34 +293,30 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for transmutes between collections whose
-    /// types have different ABI, size or alignment.
+    /// Checks for transmutes from a pointer to a reference.
     ///
     /// ### Why is this bad?
-    /// This is undefined behavior.
+    /// This can always be rewritten with `&` and `*`.
     ///
     /// ### Known problems
-    /// Currently, we cannot know whether a type is a
-    /// collection, so we just lint the ones that come with `std`.
+    /// - `mem::transmute` in statics and constants is stable from Rust 1.46.0,
+    /// while dereferencing raw pointer is not stable yet.
+    /// If you need to do this in those places,
+    /// you would have to use `transmute` instead.
     ///
     /// ### Example
-    /// ```no_run
-    /// // different size, therefore likely out-of-bounds memory access
-    /// // You absolutely do not want this in your code!
+    /// ```rust,ignore
     /// unsafe {
-    ///     std::mem::transmute::<_, Vec<u32>>(vec![2_u16])
-    /// };
-    /// ```
-    ///
-    /// You must always iterate, map and collect the values:
+    ///     let _: &T = std::mem::transmute(p); // where p: *const T
+    /// }
     ///
-    /// ```no_run
-    /// vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();
+    /// // can be written:
+    /// let _: &T = &*p;
     /// ```
-    #[clippy::version = "1.40.0"]
-    pub UNSOUND_COLLECTION_TRANSMUTE,
-    correctness,
-    "transmute between collections of layout-incompatible types"
+    #[clippy::version = "pre 1.29.0"]
+    pub TRANSMUTE_PTR_TO_REF,
+    complexity,
+    "transmutes from a pointer to a reference type"
 }
 
 declare_clippy_lint! {
@@ -311,6 +348,31 @@ declare_clippy_lint! {
     "transmute to or from a type with an undefined representation"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///Checks for transmutes that could be a pointer cast.
+    ///
+    /// ### Why is this bad?
+    /// Readability. The code tricks people into thinking that
+    /// something complex is going on.
+    ///
+    /// ### Example
+    ///
+    /// ```no_run
+    /// # let p: *const [i32] = &[];
+    /// unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let p: *const [i32] = &[];
+    /// p as *const [u16];
+    /// ```
+    #[clippy::version = "1.47.0"]
+    pub TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+    complexity,
+    "transmutes that could be a pointer cast"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for transmute calls which would receive a null pointer.
@@ -335,160 +397,100 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for null function pointer creation through transmute.
+    /// Checks for transmutes between collections whose
+    /// types have different ABI, size or alignment.
     ///
     /// ### Why is this bad?
-    /// Creating a null function pointer is undefined behavior.
-    ///
-    /// More info: https://doc.rust-lang.org/nomicon/ffi.html#the-nullable-pointer-optimization
+    /// This is undefined behavior.
     ///
     /// ### Known problems
-    /// Not all cases can be detected at the moment of this writing.
-    /// For example, variables which hold a null pointer and are then fed to a `transmute`
-    /// call, aren't detectable yet.
+    /// Currently, we cannot know whether a type is a
+    /// collection, so we just lint the ones that come with `std`.
     ///
     /// ### Example
     /// ```no_run
-    /// let null_fn: fn() = unsafe { std::mem::transmute( std::ptr::null::<()>() ) };
+    /// // different size, therefore likely out-of-bounds memory access
+    /// // You absolutely do not want this in your code!
+    /// unsafe {
+    ///     std::mem::transmute::<_, Vec<u32>>(vec![2_u16])
+    /// };
     /// ```
-    /// Use instead:
+    ///
+    /// You must always iterate, map and collect the values:
+    ///
     /// ```no_run
-    /// let null_fn: Option<fn()> = None;
+    /// vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();
     /// ```
-    #[clippy::version = "1.68.0"]
-    pub TRANSMUTE_NULL_TO_FN,
+    #[clippy::version = "1.40.0"]
+    pub UNSOUND_COLLECTION_TRANSMUTE,
     correctness,
-    "transmute results in a null function pointer, which is undefined behavior"
+    "transmute between collections of layout-incompatible types"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for integer validity checks, followed by a transmute that is (incorrectly) evaluated
-    /// eagerly (e.g. using `bool::then_some`).
+    /// Checks for transmutes to the original type of the object
+    /// and transmutes that could be a cast.
     ///
     /// ### Why is this bad?
-    /// Eager evaluation means that the `transmute` call is executed regardless of whether the condition is true or false.
-    /// This can introduce unsoundness and other subtle bugs.
+    /// Readability. The code tricks people into thinking that
+    /// something complex is going on.
     ///
     /// ### Example
-    /// Consider the following function which is meant to convert an unsigned integer to its enum equivalent via transmute.
-    ///
-    /// ```no_run
-    /// #[repr(u8)]
-    /// enum Opcode {
-    ///     Add = 0,
-    ///     Sub = 1,
-    ///     Mul = 2,
-    ///     Div = 3
-    /// }
-    ///
-    /// fn int_to_opcode(op: u8) -> Option<Opcode> {
-    ///     (op < 4).then_some(unsafe { std::mem::transmute(op) })
-    /// }
-    /// ```
-    /// This may appear fine at first given that it checks that the `u8` is within the validity range of the enum,
-    /// *however* the transmute is evaluated eagerly, meaning that it executes even if `op >= 4`!
-    ///
-    /// This makes the function unsound, because it is possible for the caller to cause undefined behavior
-    /// (creating an enum with an invalid bitpattern) entirely in safe code only by passing an incorrect value,
-    /// which is normally only a bug that is possible in unsafe code.
-    ///
-    /// One possible way in which this can go wrong practically is that the compiler sees it as:
-    /// ```rust,ignore (illustrative)
-    /// let temp: Foo = unsafe { std::mem::transmute(op) };
-    /// (0 < 4).then_some(temp)
-    /// ```
-    /// and optimizes away the `(0 < 4)` check based on the assumption that since a `Foo` was created from `op` with the validity range `0..3`,
-    /// it is **impossible** for this condition to be false.
-    ///
-    /// In short, it is possible for this function to be optimized in a way that makes it [never return `None`](https://godbolt.org/z/ocrcenevq),
-    /// even if passed the value `4`.
-    ///
-    /// This can be avoided by instead using lazy evaluation. For the example above, this should be written:
-    /// ```rust,ignore (illustrative)
-    /// fn int_to_opcode(op: u8) -> Option<Opcode> {
-    ///     (op < 4).then(|| unsafe { std::mem::transmute(op) })
-    ///              ^^^^ ^^ `bool::then` only executes the closure if the condition is true!
-    /// }
+    /// ```rust,ignore
+    /// core::intrinsics::transmute(t); // where the result type is the same as `t`'s
     /// ```
-    #[clippy::version = "1.77.0"]
-    pub EAGER_TRANSMUTE,
-    correctness,
-    "eager evaluation of `transmute`"
+    #[clippy::version = "pre 1.29.0"]
+    pub USELESS_TRANSMUTE,
+    complexity,
+    "transmutes that have the same to and from types or could be a cast/coercion"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks if transmute calls have all generics specified.
+    /// Checks for transmutes that can't ever be correct on any
+    /// architecture.
     ///
     /// ### Why is this bad?
-    /// If not, one or more unexpected types could be used during `transmute()`, potentially leading
-    /// to Undefined Behavior or other problems.
-    ///
-    /// This is particularly dangerous in case a seemingly innocent/unrelated change causes type
-    /// inference to result in a different type. For example, if `transmute()` is the tail
-    /// expression of an `if`-branch, and the `else`-branch type changes, the compiler may silently
-    /// infer a different type to be returned by `transmute()`. That is because the compiler is
-    /// free to change the inference of a type as long as that inference is technically correct,
-    /// regardless of the programmer's unknown expectation.
+    /// It's basically guaranteed to be undefined behavior.
     ///
-    /// Both type-parameters, the input- and the output-type, to any `transmute()` should
-    /// be given explicitly: Setting the input-type explicitly avoids confusion about what the
-    /// argument's type actually is. Setting the output-type explicitly avoids type-inference
-    /// to infer a technically correct yet unexpected type.
+    /// ### Known problems
+    /// When accessing C, users might want to store pointer
+    /// sized objects in `extradata` arguments to save an allocation.
     ///
     /// ### Example
+    /// ```ignore
+    /// let ptr: *const T = core::intrinsics::transmute('x')
     /// ```
-    /// # unsafe {
-    /// let mut x: i32 = 0;
-    /// // Avoid "naked" calls to `transmute()`!
-    /// x = std::mem::transmute([1u16, 2u16]);
-    ///
-    /// // `first_answers` is intended to transmute a slice of bool to a slice of u8.
-    /// // But the programmer forgot to index the first element of the outer slice,
-    /// // so we are actually transmuting from "pointers to slices" instead of
-    /// // transmuting from "a slice of bool", causing a nonsensical result.
-    /// let the_answers: &[&[bool]] = &[&[true, false, true]];
-    /// let first_answers: &[u8] = std::mem::transmute(the_answers);
-    /// # }
-    /// ```
-    /// Use instead:
-    /// ```
-    /// # unsafe {
-    /// let x = std::mem::transmute::<[u16; 2], i32>([1u16, 2u16]);
-    ///
-    /// // The explicit type parameters on `transmute()` makes the intention clear,
-    /// // and cause a type-error if the actual types don't match our expectation.
-    /// let the_answers: &[&[bool]] = &[&[true, false, true]];
-    /// let first_answers: &[u8] = std::mem::transmute::<&[bool], &[u8]>(the_answers[0]);
-    /// # }
-    /// ```
-    #[clippy::version = "1.79.0"]
-    pub MISSING_TRANSMUTE_ANNOTATIONS,
-    suspicious,
-    "warns if a transmute call doesn't have all generics specified"
+    #[clippy::version = "pre 1.29.0"]
+    pub WRONG_TRANSMUTE,
+    correctness,
+    "transmutes that are confusing at best, undefined behavior at worst and always useless"
 }
 
-pub struct Transmute {
-    msrv: Msrv,
-}
 impl_lint_pass!(Transmute => [
     CROSSPOINTER_TRANSMUTE,
-    TRANSMUTE_PTR_TO_REF,
-    TRANSMUTE_PTR_TO_PTR,
-    USELESS_TRANSMUTE,
-    WRONG_TRANSMUTE,
+    EAGER_TRANSMUTE,
+    MISSING_TRANSMUTE_ANNOTATIONS,
+    TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
     TRANSMUTE_BYTES_TO_STR,
     TRANSMUTE_INT_TO_BOOL,
     TRANSMUTE_INT_TO_NON_ZERO,
-    UNSOUND_COLLECTION_TRANSMUTE,
-    TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+    TRANSMUTE_NULL_TO_FN,
+    TRANSMUTE_PTR_TO_PTR,
+    TRANSMUTE_PTR_TO_REF,
     TRANSMUTE_UNDEFINED_REPR,
     TRANSMUTING_NULL,
-    TRANSMUTE_NULL_TO_FN,
-    EAGER_TRANSMUTE,
-    MISSING_TRANSMUTE_ANNOTATIONS,
+    UNSOUND_COLLECTION_TRANSMUTE,
+    USELESS_TRANSMUTE,
+    WRONG_TRANSMUTE,
 ]);
+
+// FIXME: Merge this lint with USELESS_TRANSMUTE once that is out of the nursery.
+
+pub struct Transmute {
+    msrv: Msrv,
+}
 impl Transmute {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index 98bf9f9fea58..8bbecb5c1954 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -40,6 +40,7 @@ declare_clippy_lint! {
     nursery,
     "checks for tuple<=>array conversions that are not done with `.into()`"
 }
+
 impl_lint_pass!(TupleArrayConversions => [TUPLE_ARRAY_CONVERSIONS]);
 
 pub struct TupleArrayConversions {
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 7d97ce97f487..17f1adf6960f 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -24,100 +24,58 @@ use rustc_span::def_id::LocalDefId;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `Box<T>` where T is a collection such as Vec anywhere in the code.
+    /// Checks for usage of `&Box<T>` anywhere in the code.
     /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
     /// ### Why is this bad?
-    /// Collections already keeps their contents in a separate area on
-    /// the heap. So if you `Box` them, you just add another level of indirection
-    /// without any benefit whatsoever.
+    /// A `&Box<T>` parameter requires the function caller to box `T` first before passing it to a function.
+    /// Using `&T` defines a concrete type for the parameter and generalizes the function, this would also
+    /// auto-deref to `&T` at the function call site if passed a `&Box<T>`.
     ///
     /// ### Example
     /// ```rust,ignore
-    /// struct X {
-    ///     values: Box<Vec<Foo>>,
-    /// }
+    /// fn foo(bar: &Box<T>) { ... }
     /// ```
     ///
     /// Better:
     ///
     /// ```rust,ignore
-    /// struct X {
-    ///     values: Vec<Foo>,
-    /// }
+    /// fn foo(bar: &T) { ... }
     /// ```
-    #[clippy::version = "1.57.0"]
-    pub BOX_COLLECTION,
-    perf,
-    "usage of `Box<Vec<T>>`, vector elements are already on the heap"
+    #[clippy::version = "pre 1.29.0"]
+    pub BORROWED_BOX,
+    complexity,
+    "a borrow of a boxed type"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `Vec<Box<T>>` where T: Sized anywhere in the code.
+    /// Checks for usage of `Box<T>` where T is a collection such as Vec anywhere in the code.
     /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
     /// ### Why is this bad?
-    /// `Vec` already keeps its contents in a separate area on
-    /// the heap. So if you `Box` its contents, you just add another level of indirection.
+    /// Collections already keeps their contents in a separate area on
+    /// the heap. So if you `Box` them, you just add another level of indirection
+    /// without any benefit whatsoever.
     ///
     /// ### Example
-    /// ```no_run
+    /// ```rust,ignore
     /// struct X {
-    ///     values: Vec<Box<i32>>,
+    ///     values: Box<Vec<Foo>>,
     /// }
     /// ```
     ///
     /// Better:
     ///
-    /// ```no_run
+    /// ```rust,ignore
     /// struct X {
-    ///     values: Vec<i32>,
-    /// }
-    /// ```
-    #[clippy::version = "1.33.0"]
-    pub VEC_BOX,
-    complexity,
-    "usage of `Vec<Box<T>>` where T: Sized, vector elements are already on the heap"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `Option<Option<_>>` in function signatures and type
-    /// definitions
-    ///
-    /// ### Why is this bad?
-    /// `Option<_>` represents an optional value. `Option<Option<_>>`
-    /// represents an optional value which itself wraps an optional. This is logically the
-    /// same thing as an optional value but has an unneeded extra level of wrapping.
-    ///
-    /// If you have a case where `Some(Some(_))`, `Some(None)` and `None` are distinct cases,
-    /// consider a custom `enum` instead, with clear names for each case.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn get_data() -> Option<Option<u32>> {
-    ///     None
-    /// }
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```no_run
-    /// pub enum Contents {
-    ///     Data(Vec<u8>), // Was Some(Some(Vec<u8>))
-    ///     NotYetFetched, // Was Some(None)
-    ///     None,          // Was None
-    /// }
-    ///
-    /// fn get_data() -> Contents {
-    ///     Contents::None
+    ///     values: Vec<Foo>,
     /// }
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OPTION_OPTION,
-    pedantic,
-    "usage of `Option<Option<T>>`"
+    #[clippy::version = "1.57.0"]
+    pub BOX_COLLECTION,
+    perf,
+    "usage of `Box<Vec<T>>`, vector elements are already on the heap"
 }
 
 declare_clippy_lint! {
@@ -162,53 +120,80 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `&Box<T>` anywhere in the code.
-    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
+    /// Checks for usage of `Option<Option<_>>` in function signatures and type
+    /// definitions
     ///
     /// ### Why is this bad?
-    /// A `&Box<T>` parameter requires the function caller to box `T` first before passing it to a function.
-    /// Using `&T` defines a concrete type for the parameter and generalizes the function, this would also
-    /// auto-deref to `&T` at the function call site if passed a `&Box<T>`.
+    /// `Option<_>` represents an optional value. `Option<Option<_>>`
+    /// represents an optional value which itself wraps an optional. This is logically the
+    /// same thing as an optional value but has an unneeded extra level of wrapping.
+    ///
+    /// If you have a case where `Some(Some(_))`, `Some(None)` and `None` are distinct cases,
+    /// consider a custom `enum` instead, with clear names for each case.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// fn foo(bar: &Box<T>) { ... }
+    /// ```no_run
+    /// fn get_data() -> Option<Option<u32>> {
+    ///     None
+    /// }
     /// ```
     ///
     /// Better:
     ///
-    /// ```rust,ignore
-    /// fn foo(bar: &T) { ... }
+    /// ```no_run
+    /// pub enum Contents {
+    ///     Data(Vec<u8>), // Was Some(Some(Vec<u8>))
+    ///     NotYetFetched, // Was Some(None)
+    ///     None,          // Was None
+    /// }
+    ///
+    /// fn get_data() -> Contents {
+    ///     Contents::None
+    /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub BORROWED_BOX,
-    complexity,
-    "a borrow of a boxed type"
+    pub OPTION_OPTION,
+    pedantic,
+    "usage of `Option<Option<T>>`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of redundant allocations anywhere in the code.
+    /// Detects needlessly owned `Cow` types.
     ///
     /// ### Why is this bad?
-    /// Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Arc<T>>`, `Rc<Box<T>>`, `Arc<&T>`, `Arc<Rc<T>>`,
-    /// `Arc<Arc<T>>`, `Arc<Box<T>>`, `Box<&T>`, `Box<Rc<T>>`, `Box<Arc<T>>`, `Box<Box<T>>`, add an unnecessary level of indirection.
+    /// The borrowed types are usually more flexible, in that e.g. a
+    /// `Cow<'_, str>` can accept both `&str` and `String` while
+    /// `Cow<'_, String>` can only accept `&String` and `String`. In
+    /// particular, `&str` is more general, because it allows for string
+    /// literals while `&String` can only be borrowed from a heap-owned
+    /// `String`).
+    ///
+    /// ### Known Problems
+    /// The lint does not check for usage of the type. There may be external
+    /// interfaces that require the use of an owned type.
+    ///
+    /// At least the `CString` type also has a different API than `CStr`: The
+    /// former has an `as_bytes` method which the latter calls `to_bytes`.
+    /// There is no guarantee that other types won't gain additional methods
+    /// leading to a similar mismatch.
+    ///
+    /// In addition, the lint only checks for the known problematic types
+    /// `String`, `Vec<_>`, `CString`, `OsString` and `PathBuf`. Custom types
+    /// that implement `ToOwned` will not be detected.
     ///
     /// ### Example
     /// ```no_run
-    /// # use std::rc::Rc;
-    /// fn foo(bar: Rc<&usize>) {}
+    /// let wrogn: std::borrow::Cow<'_, Vec<u8>>;
     /// ```
-    ///
-    /// Better:
-    ///
+    /// Use instead:
     /// ```no_run
-    /// fn foo(bar: &usize) {}
+    /// let right: std::borrow::Cow<'_, [u8]>;
     /// ```
-    #[clippy::version = "1.44.0"]
-    pub REDUNDANT_ALLOCATION,
-    perf,
-    "redundant allocation"
+    #[clippy::version = "1.87.0"]
+    pub OWNED_COW,
+    style,
+    "needlessly owned Cow type"
 }
 
 declare_clippy_lint! {
@@ -246,6 +231,64 @@ declare_clippy_lint! {
     "shared ownership of a buffer type"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `Rc<Mutex<T>>`.
+    ///
+    /// ### Why restrict this?
+    /// `Rc` is used in single thread and `Mutex` is used in multi thread.
+    /// Consider using `Rc<RefCell<T>>` in single thread or `Arc<Mutex<T>>` in multi thread.
+    ///
+    /// ### Known problems
+    /// Sometimes combining generic types can lead to the requirement that a
+    /// type use Rc in conjunction with Mutex. We must consider those cases false positives, but
+    /// alas they are quite hard to rule out. Luckily they are also rare.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// use std::rc::Rc;
+    /// use std::sync::Mutex;
+    /// fn foo(interned: Rc<Mutex<i32>>) { ... }
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust,ignore
+    /// use std::rc::Rc;
+    /// use std::cell::RefCell
+    /// fn foo(interned: Rc<RefCell<i32>>) { ... }
+    /// ```
+    #[clippy::version = "1.55.0"]
+    pub RC_MUTEX,
+    restriction,
+    "usage of `Rc<Mutex<T>>`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of redundant allocations anywhere in the code.
+    ///
+    /// ### Why is this bad?
+    /// Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Arc<T>>`, `Rc<Box<T>>`, `Arc<&T>`, `Arc<Rc<T>>`,
+    /// `Arc<Arc<T>>`, `Arc<Box<T>>`, `Box<&T>`, `Box<Rc<T>>`, `Box<Arc<T>>`, `Box<Box<T>>`, add an unnecessary level of indirection.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::rc::Rc;
+    /// fn foo(bar: Rc<&usize>) {}
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```no_run
+    /// fn foo(bar: &usize) {}
+    /// ```
+    #[clippy::version = "1.44.0"]
+    pub REDUNDANT_ALLOCATION,
+    perf,
+    "redundant allocation"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for types used in structs, parameters and `let`
@@ -321,95 +364,52 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `Rc<Mutex<T>>`.
-    ///
-    /// ### Why restrict this?
-    /// `Rc` is used in single thread and `Mutex` is used in multi thread.
-    /// Consider using `Rc<RefCell<T>>` in single thread or `Arc<Mutex<T>>` in multi thread.
+    /// Checks for usage of `Vec<Box<T>>` where T: Sized anywhere in the code.
+    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
-    /// ### Known problems
-    /// Sometimes combining generic types can lead to the requirement that a
-    /// type use Rc in conjunction with Mutex. We must consider those cases false positives, but
-    /// alas they are quite hard to rule out. Luckily they are also rare.
+    /// ### Why is this bad?
+    /// `Vec` already keeps its contents in a separate area on
+    /// the heap. So if you `Box` its contents, you just add another level of indirection.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// use std::rc::Rc;
-    /// use std::sync::Mutex;
-    /// fn foo(interned: Rc<Mutex<i32>>) { ... }
+    /// ```no_run
+    /// struct X {
+    ///     values: Vec<Box<i32>>,
+    /// }
     /// ```
     ///
     /// Better:
     ///
-    /// ```rust,ignore
-    /// use std::rc::Rc;
-    /// use std::cell::RefCell
-    /// fn foo(interned: Rc<RefCell<i32>>) { ... }
-    /// ```
-    #[clippy::version = "1.55.0"]
-    pub RC_MUTEX,
-    restriction,
-    "usage of `Rc<Mutex<T>>`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects needlessly owned `Cow` types.
-    ///
-    /// ### Why is this bad?
-    /// The borrowed types are usually more flexible, in that e.g. a
-    /// `Cow<'_, str>` can accept both `&str` and `String` while
-    /// `Cow<'_, String>` can only accept `&String` and `String`. In
-    /// particular, `&str` is more general, because it allows for string
-    /// literals while `&String` can only be borrowed from a heap-owned
-    /// `String`).
-    ///
-    /// ### Known Problems
-    /// The lint does not check for usage of the type. There may be external
-    /// interfaces that require the use of an owned type.
-    ///
-    /// At least the `CString` type also has a different API than `CStr`: The
-    /// former has an `as_bytes` method which the latter calls `to_bytes`.
-    /// There is no guarantee that other types won't gain additional methods
-    /// leading to a similar mismatch.
-    ///
-    /// In addition, the lint only checks for the known problematic types
-    /// `String`, `Vec<_>`, `CString`, `OsString` and `PathBuf`. Custom types
-    /// that implement `ToOwned` will not be detected.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let wrogn: std::borrow::Cow<'_, Vec<u8>>;
-    /// ```
-    /// Use instead:
     /// ```no_run
-    /// let right: std::borrow::Cow<'_, [u8]>;
+    /// struct X {
+    ///     values: Vec<i32>,
+    /// }
     /// ```
-    #[clippy::version = "1.87.0"]
-    pub OWNED_COW,
-    style,
-    "needlessly owned Cow type"
-}
-
-pub struct Types {
-    vec_box_size_threshold: u64,
-    type_complexity_threshold: u64,
-    avoid_breaking_exported_api: bool,
+    #[clippy::version = "1.33.0"]
+    pub VEC_BOX,
+    complexity,
+    "usage of `Vec<Box<T>>` where T: Sized, vector elements are already on the heap"
 }
 
 impl_lint_pass!(Types => [
+    BORROWED_BOX,
     BOX_COLLECTION,
-    VEC_BOX,
-    OPTION_OPTION,
     LINKEDLIST,
-    BORROWED_BOX,
-    REDUNDANT_ALLOCATION,
+    OPTION_OPTION,
+    OWNED_COW,
     RC_BUFFER,
     RC_MUTEX,
+    REDUNDANT_ALLOCATION,
     TYPE_COMPLEXITY,
-    OWNED_COW
+    VEC_BOX,
 ]);
 
+pub struct Types {
+    vec_box_size_threshold: u64,
+    type_complexity_threshold: u64,
+    avoid_breaking_exported_api: bool,
+}
+
 impl<'tcx> LateLintPass<'tcx> for Types {
     fn check_fn(
         &mut self,
diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
index 48f1cda9ee7b..8bed3d334fc9 100644
--- a/clippy_lints/src/unconditional_recursion.rs
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -71,6 +71,8 @@ declare_clippy_lint! {
     "detect unconditional recursion in some traits implementation"
 }
 
+impl_lint_pass!(UnconditionalRecursion => [UNCONDITIONAL_RECURSION]);
+
 #[derive(Default)]
 pub struct UnconditionalRecursion {
     /// The key is the `DefId` of the type implementing the `Default` trait and the value is the
@@ -78,8 +80,6 @@ pub struct UnconditionalRecursion {
     default_impl_for_type: FxHashMap<DefId, DefId>,
 }
 
-impl_lint_pass!(UnconditionalRecursion => [UNCONDITIONAL_RECURSION]);
-
 fn span_error(cx: &LateContext<'_>, method_span: Span, expr: &Expr<'_>) {
     span_lint_and_then(
         cx,
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 1b26b1b32b80..60775d1856eb 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -63,6 +63,7 @@ declare_clippy_lint! {
     restriction,
     "creating an unsafe block without explaining why it is safe"
 }
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `// SAFETY: ` comments on safe code.
@@ -92,6 +93,11 @@ declare_clippy_lint! {
     "annotating safe code with a safety comment"
 }
 
+impl_lint_pass!(UndocumentedUnsafeBlocks => [
+    UNDOCUMENTED_UNSAFE_BLOCKS,
+    UNNECESSARY_SAFETY_COMMENT,
+]);
+
 pub struct UndocumentedUnsafeBlocks {
     accept_comment_above_statement: bool,
     accept_comment_above_attributes: bool,
@@ -106,8 +112,6 @@ impl UndocumentedUnsafeBlocks {
     }
 }
 
-impl_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS, UNNECESSARY_SAFETY_COMMENT]);
-
 impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
         if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index 79571b0409d2..bef8b8fb4ee0 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -72,7 +72,11 @@ declare_clippy_lint! {
     "using a Unicode literal not in NFC normal form (see [Unicode tr15](http://www.unicode.org/reports/tr15/) for further information)"
 }
 
-declare_lint_pass!(Unicode => [INVISIBLE_CHARACTERS, NON_ASCII_LITERAL, UNICODE_NOT_NFC]);
+declare_lint_pass!(Unicode => [
+    INVISIBLE_CHARACTERS,
+    NON_ASCII_LITERAL,
+    UNICODE_NOT_NFC,
+]);
 
 impl LateLintPass<'_> for Unicode {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index 4ffcc247acf6..ca29975392de 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -28,6 +28,27 @@ declare_clippy_lint! {
     "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for passing a unit value as an argument to a function without using a
+    /// unit literal (`()`).
+    ///
+    /// ### Why is this bad?
+    /// This is likely the result of an accidental semicolon.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// foo({
+    ///     let a = bar();
+    ///     baz(a);
+    /// })
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub UNIT_ARG,
+    complexity,
+    "passing unit to a function"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for comparisons to unit. This includes all binary
@@ -76,33 +97,12 @@ declare_clippy_lint! {
     "comparing unit values"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for passing a unit value as an argument to a function without using a
-    /// unit literal (`()`).
-    ///
-    /// ### Why is this bad?
-    /// This is likely the result of an accidental semicolon.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// foo({
-    ///     let a = bar();
-    ///     baz(a);
-    /// })
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub UNIT_ARG,
-    complexity,
-    "passing unit to a function"
-}
+impl_lint_pass!(UnitTypes => [LET_UNIT_VALUE, UNIT_ARG, UNIT_CMP]);
 
 pub struct UnitTypes {
     format_args: FormatArgsStorage,
 }
 
-impl_lint_pass!(UnitTypes => [LET_UNIT_VALUE, UNIT_CMP, UNIT_ARG]);
-
 impl UnitTypes {
     pub fn new(format_args: FormatArgsStorage) -> Self {
         Self { format_args }
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index 6e3e41f08ee5..8d4f1a153def 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -40,13 +40,13 @@ declare_clippy_lint! {
     "Needlessly returning a Box"
 }
 
+impl_lint_pass!(UnnecessaryBoxReturns => [UNNECESSARY_BOX_RETURNS]);
+
 pub struct UnnecessaryBoxReturns {
     avoid_breaking_exported_api: bool,
     maximum_size: u64,
 }
 
-impl_lint_pass!(UnnecessaryBoxReturns => [UNNECESSARY_BOX_RETURNS]);
-
 impl UnnecessaryBoxReturns {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index fba530d0dfca..6754c224e7e4 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -31,7 +31,10 @@ declare_clippy_lint! {
     complexity,
     "using `map`/`map_err` on `Option` or `Result` constructors"
 }
-declare_lint_pass!(UnnecessaryMapOnConstructor => [UNNECESSARY_MAP_ON_CONSTRUCTOR]);
+
+declare_lint_pass!(UnnecessaryMapOnConstructor => [
+    UNNECESSARY_MAP_ON_CONSTRUCTOR,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for UnnecessaryMapOnConstructor {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 0388450c9f7e..56792bdcdb47 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -30,7 +30,10 @@ declare_clippy_lint! {
     style,
     "detects cases of references to owned empty strings being passed as an argument to a function expecting `&str`"
 }
-declare_lint_pass!(UnnecessaryOwnedEmptyStrings => [UNNECESSARY_OWNED_EMPTY_STRINGS]);
+
+declare_lint_pass!(UnnecessaryOwnedEmptyStrings => [
+    UNNECESSARY_OWNED_EMPTY_STRINGS,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
diff --git a/clippy_lints/src/unnecessary_semicolon.rs b/clippy_lints/src/unnecessary_semicolon.rs
index e1e450a52fdf..8a76fdecc0a6 100644
--- a/clippy_lints/src/unnecessary_semicolon.rs
+++ b/clippy_lints/src/unnecessary_semicolon.rs
@@ -35,13 +35,13 @@ declare_clippy_lint! {
     "unnecessary semicolon after expression returning `()`"
 }
 
+impl_lint_pass!(UnnecessarySemicolon => [UNNECESSARY_SEMICOLON]);
+
 #[derive(Default)]
 pub struct UnnecessarySemicolon {
     last_statements: Vec<(HirId, bool)>,
 }
 
-impl_lint_pass!(UnnecessarySemicolon => [UNNECESSARY_SEMICOLON]);
-
 impl UnnecessarySemicolon {
     /// Enter or leave a block, remembering the last statement of the block.
     fn handle_block(&mut self, cx: &LateContext<'_>, block: &Block<'_>, enter: bool) {
diff --git a/clippy_lints/src/unnecessary_struct_initialization.rs b/clippy_lints/src/unnecessary_struct_initialization.rs
index 51397accefea..65a3c2f304af 100644
--- a/clippy_lints/src/unnecessary_struct_initialization.rs
+++ b/clippy_lints/src/unnecessary_struct_initialization.rs
@@ -45,6 +45,7 @@ declare_clippy_lint! {
     nursery,
     "struct built from a base that can be written mode concisely"
 }
+
 declare_lint_pass!(UnnecessaryStruct => [UNNECESSARY_STRUCT_INITIALIZATION]);
 
 impl LateLintPass<'_> for UnnecessaryStruct {
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 29747cf0e447..17e05db644b0 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -60,12 +60,12 @@ declare_clippy_lint! {
     "functions that only return `Ok` or `Some`"
 }
 
+impl_lint_pass!(UnnecessaryWraps => [UNNECESSARY_WRAPS]);
+
 pub struct UnnecessaryWraps {
     avoid_breaking_exported_api: bool,
 }
 
-impl_lint_pass!(UnnecessaryWraps => [UNNECESSARY_WRAPS]);
-
 impl UnnecessaryWraps {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 12f8bd50e144..712dcf60e695 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -49,6 +49,8 @@ declare_clippy_lint! {
     "unnested or-patterns, e.g., `Foo(Bar) | Foo(Baz) instead of `Foo(Bar | Baz)`"
 }
 
+impl_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
+
 pub struct UnnestedOrPatterns {
     msrv: MsrvStack,
 }
@@ -61,8 +63,6 @@ impl UnnestedOrPatterns {
     }
 }
 
-impl_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
-
 impl EarlyLintPass for UnnestedOrPatterns {
     fn check_arm(&mut self, cx: &EarlyContext<'_>, a: &ast::Arm) {
         if self.msrv.meets(msrvs::OR_PATTERNS) {
diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 5a3e4b7adf64..a4ebd8860dc0 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -43,6 +43,8 @@ declare_clippy_lint! {
     "finds async functions with no await statements"
 }
 
+impl_lint_pass!(UnusedAsync => [UNUSED_ASYNC]);
+
 #[derive(Default)]
 pub struct UnusedAsync {
     /// Keeps track of async functions used as values (i.e. path expressions to async functions that
@@ -60,8 +62,6 @@ struct UnusedAsyncFn {
     await_in_async_block: Option<Span>,
 }
 
-impl_lint_pass!(UnusedAsync => [UNUSED_ASYNC]);
-
 struct AsyncFnVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     found_await: bool,
diff --git a/clippy_lints/src/unused_result_ok.rs b/clippy_lints/src/unused_result_ok.rs
index fe323a0b7b0c..c1dc64e0bbe8 100644
--- a/clippy_lints/src/unused_result_ok.rs
+++ b/clippy_lints/src/unused_result_ok.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     restriction,
     "Use of `.ok()` to silence `Result`'s `#[must_use]` is misleading. Use `let _ =` instead."
 }
+
 declare_lint_pass!(UnusedResultOk => [UNUSED_RESULT_OK]);
 
 impl LateLintPass<'_> for UnusedResultOk {
diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index c21004b5362d..a8af8eafe8dc 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     nursery,
     "Uselessly rounding a whole number floating-point literal"
 }
+
 declare_lint_pass!(UnusedRounding => [UNUSED_ROUNDING]);
 
 fn is_useless_rounding(cx: &EarlyContext<'_>, expr: &Expr) -> Option<(Symbol, String)> {
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index dff39974a373..587cc8631d02 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -36,12 +36,12 @@ declare_clippy_lint! {
     "methods that contain a `self` argument but don't use it"
 }
 
+impl_lint_pass!(UnusedSelf => [UNUSED_SELF]);
+
 pub struct UnusedSelf {
     avoid_breaking_exported_api: bool,
 }
 
-impl_lint_pass!(UnusedSelf => [UNUSED_SELF]);
-
 impl UnusedSelf {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
diff --git a/clippy_lints/src/unused_trait_names.rs b/clippy_lints/src/unused_trait_names.rs
index 12f2804dbaa1..be41bdd38020 100644
--- a/clippy_lints/src/unused_trait_names.rs
+++ b/clippy_lints/src/unused_trait_names.rs
@@ -45,6 +45,8 @@ declare_clippy_lint! {
     "use items that import a trait but only use it anonymously"
 }
 
+impl_lint_pass!(UnusedTraitNames => [UNUSED_TRAIT_NAMES]);
+
 pub struct UnusedTraitNames {
     msrv: Msrv,
 }
@@ -55,8 +57,6 @@ impl UnusedTraitNames {
     }
 }
 
-impl_lint_pass!(UnusedTraitNames => [UNUSED_TRAIT_NAMES]);
-
 impl<'tcx> LateLintPass<'tcx> for UnusedTraitNames {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if !item.span.from_expansion()
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index a95f2b681add..cfd3f420db5a 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -24,62 +24,64 @@ use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls of `unwrap[_err]()` that cannot fail.
+    /// Checks for calls of `unwrap[_err]()` that will always fail.
     ///
     /// ### Why is this bad?
-    /// Using `if let` or `match` is more idiomatic.
+    /// If panicking is desired, an explicit `panic!()` should be used.
+    ///
+    /// ### Known problems
+    /// This lint only checks `if` conditions not assignments.
+    /// So something like `let x: Option<()> = None; x.unwrap();` will not be recognized.
     ///
     /// ### Example
     /// ```no_run
     /// # let option = Some(0);
     /// # fn do_something_with(_x: usize) {}
-    /// if option.is_some() {
+    /// if option.is_none() {
     ///     do_something_with(option.unwrap())
     /// }
     /// ```
     ///
-    /// Could be written:
-    ///
-    /// ```no_run
-    /// # let option = Some(0);
-    /// # fn do_something_with(_x: usize) {}
-    /// if let Some(value) = option {
-    ///     do_something_with(value)
-    /// }
-    /// ```
+    /// This code will always panic. The if condition should probably be inverted.
     #[clippy::version = "pre 1.29.0"]
-    pub UNNECESSARY_UNWRAP,
-    complexity,
-    "checks for calls of `unwrap[_err]()` that cannot fail"
+    pub PANICKING_UNWRAP,
+    correctness,
+    "checks for calls of `unwrap[_err]()` that will always fail"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls of `unwrap[_err]()` that will always fail.
+    /// Checks for calls of `unwrap[_err]()` that cannot fail.
     ///
     /// ### Why is this bad?
-    /// If panicking is desired, an explicit `panic!()` should be used.
-    ///
-    /// ### Known problems
-    /// This lint only checks `if` conditions not assignments.
-    /// So something like `let x: Option<()> = None; x.unwrap();` will not be recognized.
+    /// Using `if let` or `match` is more idiomatic.
     ///
     /// ### Example
     /// ```no_run
     /// # let option = Some(0);
     /// # fn do_something_with(_x: usize) {}
-    /// if option.is_none() {
+    /// if option.is_some() {
     ///     do_something_with(option.unwrap())
     /// }
     /// ```
     ///
-    /// This code will always panic. The if condition should probably be inverted.
+    /// Could be written:
+    ///
+    /// ```no_run
+    /// # let option = Some(0);
+    /// # fn do_something_with(_x: usize) {}
+    /// if let Some(value) = option {
+    ///     do_something_with(value)
+    /// }
+    /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub PANICKING_UNWRAP,
-    correctness,
-    "checks for calls of `unwrap[_err]()` that will always fail"
+    pub UNNECESSARY_UNWRAP,
+    complexity,
+    "checks for calls of `unwrap[_err]()` that cannot fail"
 }
 
+impl_lint_pass!(Unwrap => [PANICKING_UNWRAP, UNNECESSARY_UNWRAP]);
+
 pub(crate) struct Unwrap {
     msrv: Msrv,
 }
@@ -524,8 +526,6 @@ impl<'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'_, 'tcx> {
     }
 }
 
-impl_lint_pass!(Unwrap => [PANICKING_UNWRAP, UNNECESSARY_UNWRAP]);
-
 impl<'tcx> LateLintPass<'tcx> for Unwrap {
     fn check_fn(
         &mut self,
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index f26647fa3485..aafd1153f933 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -56,7 +56,7 @@ declare_clippy_lint! {
     "functions of type `Result<..>` or `Option`<...> that contain `expect()` or `unwrap()`"
 }
 
-impl_lint_pass!(UnwrapInResult=> [UNWRAP_IN_RESULT]);
+impl_lint_pass!(UnwrapInResult => [UNWRAP_IN_RESULT]);
 
 #[derive(Clone, Copy, Eq, PartialEq)]
 enum OptionOrResult {
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 944cd91a7fda..6ea6a0ad85aa 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -39,6 +39,8 @@ declare_clippy_lint! {
     "capitalized acronyms are against the naming convention"
 }
 
+impl_lint_pass!(UpperCaseAcronyms => [UPPER_CASE_ACRONYMS]);
+
 pub struct UpperCaseAcronyms {
     avoid_breaking_exported_api: bool,
     upper_case_acronyms_aggressive: bool,
@@ -53,8 +55,6 @@ impl UpperCaseAcronyms {
     }
 }
 
-impl_lint_pass!(UpperCaseAcronyms => [UPPER_CASE_ACRONYMS]);
-
 fn contains_acronym(s: &str) -> bool {
     let mut count = 0;
     for c in s.chars() {
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 38ce9dc3f916..620874e2aebf 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -56,6 +56,8 @@ declare_clippy_lint! {
     "unnecessary structure name repetition whereas `Self` is applicable"
 }
 
+impl_lint_pass!(UseSelf => [USE_SELF]);
+
 pub struct UseSelf {
     msrv: Msrv,
     stack: Vec<StackItem>,
@@ -81,8 +83,6 @@ enum StackItem {
     NoCheck,
 }
 
-impl_lint_pass!(UseSelf => [USE_SELF]);
-
 const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
 
 impl<'tcx> LateLintPass<'tcx> for UseSelf {
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index e287a3de86bd..662da5929adb 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -41,14 +41,14 @@ declare_clippy_lint! {
     "calls to `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` which perform useless conversions to the same type"
 }
 
+impl_lint_pass!(UselessConversion => [USELESS_CONVERSION]);
+
 #[derive(Default)]
 pub struct UselessConversion {
     try_desugar_arm: Vec<HirId>,
     expn_depth: u32,
 }
 
-impl_lint_pass!(UselessConversion => [USELESS_CONVERSION]);
-
 enum MethodOrFunction {
     Method,
     Function,
diff --git a/clippy_lints/src/visibility.rs b/clippy_lints/src/visibility.rs
index d17b3df99216..74ffeb629d2b 100644
--- a/clippy_lints/src/visibility.rs
+++ b/clippy_lints/src/visibility.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     style,
     "checks for usage of `pub(self)` and `pub(in self)`."
 }
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `pub(<loc>)` with `in`.
@@ -49,6 +50,7 @@ declare_clippy_lint! {
     restriction,
     "disallows usage of `pub(<loc>)`, without `in`"
 }
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `pub(<loc>)` without `in`.
@@ -74,7 +76,12 @@ declare_clippy_lint! {
     restriction,
     "disallows usage of `pub(in <loc>)` with `in`"
 }
-declare_lint_pass!(Visibility => [NEEDLESS_PUB_SELF, PUB_WITH_SHORTHAND, PUB_WITHOUT_SHORTHAND]);
+
+declare_lint_pass!(Visibility => [
+    NEEDLESS_PUB_SELF,
+    PUB_WITHOUT_SHORTHAND,
+    PUB_WITH_SHORTHAND,
+]);
 
 impl EarlyLintPass for Visibility {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
diff --git a/clippy_lints/src/volatile_composites.rs b/clippy_lints/src/volatile_composites.rs
index 6402c3ef72c4..c7659056c937 100644
--- a/clippy_lints/src/volatile_composites.rs
+++ b/clippy_lints/src/volatile_composites.rs
@@ -57,6 +57,7 @@ declare_clippy_lint! {
     nursery,
     "warn about volatile read/write applied to composite types"
 }
+
 declare_lint_pass!(VolatileComposites => [VOLATILE_COMPOSITES]);
 
 /// Zero-sized types are intrinsically safe to use volatile on since they won't
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index a2523b5fb07c..22c46527b5c6 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -100,6 +100,8 @@ declare_clippy_lint! {
     "lint `use _::*` statements"
 }
 
+impl_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
+
 pub struct WildcardImports {
     warn_on_all: bool,
     allowed_segments: FxHashSet<String>,
@@ -114,8 +116,6 @@ impl WildcardImports {
     }
 }
 
-impl_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
-
 impl LateLintPass<'_> for WildcardImports {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if cx.sess().is_test_crate() || item.span.in_external_macro(cx.sess().source_map()) {
diff --git a/clippy_lints/src/write/mod.rs b/clippy_lints/src/write/mod.rs
index c42c047745bb..8d896046200b 100644
--- a/clippy_lints/src/write/mod.rs
+++ b/clippy_lints/src/write/mod.rs
@@ -13,50 +13,47 @@ mod with_newline;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// This lint warns when you use `println!("")` to
-    /// print a newline.
+    /// This lint warns about the use of literals as `print!`/`println!` args.
     ///
     /// ### Why is this bad?
-    /// You should use `println!()`, which is simpler.
+    /// Using literals as `println!` args is inefficient
+    /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
+    /// (i.e., just put the literal in the format string)
     ///
     /// ### Example
     /// ```no_run
-    /// println!("");
+    /// println!("{}", "foo");
     /// ```
-    ///
-    /// Use instead:
+    /// use the literal without formatting:
     /// ```no_run
-    /// println!();
+    /// println!("foo");
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub PRINTLN_EMPTY_STRING,
+    pub PRINT_LITERAL,
     style,
-    "using `println!(\"\")` with an empty string"
+    "printing a literal with a format string"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// This lint warns when you use `print!()` with a format
-    /// string that ends in a newline.
+    /// Checks for printing on *stderr*. The purpose of this lint
+    /// is to catch debugging remnants.
     ///
-    /// ### Why is this bad?
-    /// You should use `println!()` instead, which appends the
-    /// newline.
+    /// ### Why restrict this?
+    /// People often print on *stderr* while debugging an
+    /// application and might forget to remove those prints afterward.
+    ///
+    /// ### Known problems
+    /// Only catches `eprint!` and `eprintln!` calls.
     ///
     /// ### Example
     /// ```no_run
-    /// # let name = "World";
-    /// print!("Hello {}!\n", name);
-    /// ```
-    /// use println!() instead
-    /// ```no_run
-    /// # let name = "World";
-    /// println!("Hello {}!", name);
+    /// eprintln!("Hello world!");
     /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub PRINT_WITH_NEWLINE,
-    style,
-    "using `print!()` with a format string that ends in a single newline"
+    #[clippy::version = "1.50.0"]
+    pub PRINT_STDERR,
+    restriction,
+    "printing on stderr"
 }
 
 declare_clippy_lint! {
@@ -83,24 +80,50 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for printing on *stderr*. The purpose of this lint
-    /// is to catch debugging remnants.
+    /// This lint warns when you use `print!()` with a format
+    /// string that ends in a newline.
     ///
-    /// ### Why restrict this?
-    /// People often print on *stderr* while debugging an
-    /// application and might forget to remove those prints afterward.
+    /// ### Why is this bad?
+    /// You should use `println!()` instead, which appends the
+    /// newline.
     ///
-    /// ### Known problems
-    /// Only catches `eprint!` and `eprintln!` calls.
+    /// ### Example
+    /// ```no_run
+    /// # let name = "World";
+    /// print!("Hello {}!\n", name);
+    /// ```
+    /// use println!() instead
+    /// ```no_run
+    /// # let name = "World";
+    /// println!("Hello {}!", name);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub PRINT_WITH_NEWLINE,
+    style,
+    "using `print!()` with a format string that ends in a single newline"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// This lint warns when you use `println!("")` to
+    /// print a newline.
+    ///
+    /// ### Why is this bad?
+    /// You should use `println!()`, which is simpler.
     ///
     /// ### Example
     /// ```no_run
-    /// eprintln!("Hello world!");
+    /// println!("");
     /// ```
-    #[clippy::version = "1.50.0"]
-    pub PRINT_STDERR,
-    restriction,
-    "printing on stderr"
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// println!();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub PRINTLN_EMPTY_STRING,
+    style,
+    "using `println!(\"\")` with an empty string"
 }
 
 declare_clippy_lint! {
@@ -128,52 +151,30 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// This lint warns about the use of literals as `print!`/`println!` args.
+    /// This lint warns about the use of literals as `write!`/`writeln!` args.
     ///
     /// ### Why is this bad?
-    /// Using literals as `println!` args is inefficient
+    /// Using literals as `writeln!` args is inefficient
     /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
     /// (i.e., just put the literal in the format string)
     ///
     /// ### Example
     /// ```no_run
-    /// println!("{}", "foo");
-    /// ```
-    /// use the literal without formatting:
-    /// ```no_run
-    /// println!("foo");
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub PRINT_LITERAL,
-    style,
-    "printing a literal with a format string"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// This lint warns when you use `writeln!(buf, "")` to
-    /// print a newline.
-    ///
-    /// ### Why is this bad?
-    /// You should use `writeln!(buf)`, which is simpler.
-    ///
-    /// ### Example
-    /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// writeln!(buf, "");
+    /// writeln!(buf, "{}", "foo");
     /// ```
     ///
     /// Use instead:
     /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// writeln!(buf);
+    /// writeln!(buf, "foo");
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub WRITELN_EMPTY_STRING,
+    pub WRITE_LITERAL,
     style,
-    "using `writeln!(buf, \"\")` with an empty string"
+    "writing a literal with a format string"
 }
 
 declare_clippy_lint! {
@@ -209,32 +210,43 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// This lint warns about the use of literals as `write!`/`writeln!` args.
+    /// This lint warns when you use `writeln!(buf, "")` to
+    /// print a newline.
     ///
     /// ### Why is this bad?
-    /// Using literals as `writeln!` args is inefficient
-    /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
-    /// (i.e., just put the literal in the format string)
+    /// You should use `writeln!(buf)`, which is simpler.
     ///
     /// ### Example
     /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// writeln!(buf, "{}", "foo");
+    /// writeln!(buf, "");
     /// ```
     ///
     /// Use instead:
     /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// writeln!(buf, "foo");
+    /// writeln!(buf);
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub WRITE_LITERAL,
+    pub WRITELN_EMPTY_STRING,
     style,
-    "writing a literal with a format string"
+    "using `writeln!(buf, \"\")` with an empty string"
 }
 
+impl_lint_pass!(Write => [
+    PRINTLN_EMPTY_STRING,
+    PRINT_LITERAL,
+    PRINT_STDERR,
+    PRINT_STDOUT,
+    PRINT_WITH_NEWLINE,
+    USE_DEBUG,
+    WRITELN_EMPTY_STRING,
+    WRITE_LITERAL,
+    WRITE_WITH_NEWLINE,
+]);
+
 pub struct Write {
     format_args: FormatArgsStorage,
     // The outermost `impl Debug` we're currently in. While we're in one, `USE_DEBUG` is deactivated
@@ -256,18 +268,6 @@ impl Write {
     }
 }
 
-impl_lint_pass!(Write => [
-    PRINT_WITH_NEWLINE,
-    PRINTLN_EMPTY_STRING,
-    PRINT_STDOUT,
-    PRINT_STDERR,
-    USE_DEBUG,
-    PRINT_LITERAL,
-    WRITE_WITH_NEWLINE,
-    WRITELN_EMPTY_STRING,
-    WRITE_LITERAL,
-]);
-
 impl<'tcx> LateLintPass<'tcx> for Write {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         // Only check for `impl Debug`s if we're not already in one
diff --git a/clippy_lints/src/zombie_processes.rs b/clippy_lints/src/zombie_processes.rs
index 0319f3e656e1..4e83984146d7 100644
--- a/clippy_lints/src/zombie_processes.rs
+++ b/clippy_lints/src/zombie_processes.rs
@@ -54,6 +54,7 @@ declare_clippy_lint! {
     suspicious,
     "not waiting on a spawned child process"
 }
+
 declare_lint_pass!(ZombieProcesses => [ZOMBIE_PROCESSES]);
 
 impl<'tcx> LateLintPass<'tcx> for ZombieProcesses {